from typing import Any, Dict, Type, TypeVar, Tuple, Optional, BinaryIO, TextIO, TYPE_CHECKING

from typing import List


from attrs import define as _attrs_define
from attrs import field as _attrs_field

from ..types import UNSET, Unset

from typing import Union
from typing import cast
from typing import cast, List
from typing import Dict
import datetime
from dateutil.parser import isoparse
from ..types import UNSET, Unset

if TYPE_CHECKING:
  from ..models.user_usage import UserUsage





T = TypeVar("T", bound="User")


@_attrs_define
class User:
    """ 
        Attributes:
            email (str):
            username (str):
            is_admin (bool):
            is_super_admin (bool):
            created_at (datetime.datetime):
            operator (bool):
            disabled (bool):
            folders (List[str]):
            folders_owners (List[str]):
            groups (Union[Unset, List[str]]):
            usage (Union[Unset, UserUsage]):
     """

    email: str
    username: str
    is_admin: bool
    is_super_admin: bool
    created_at: datetime.datetime
    operator: bool
    disabled: bool
    folders: List[str]
    folders_owners: List[str]
    groups: Union[Unset, List[str]] = UNSET
    usage: Union[Unset, 'UserUsage'] = UNSET
    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)


    def to_dict(self) -> Dict[str, Any]:
        from ..models.user_usage import UserUsage
        email = self.email
        username = self.username
        is_admin = self.is_admin
        is_super_admin = self.is_super_admin
        created_at = self.created_at.isoformat()

        operator = self.operator
        disabled = self.disabled
        folders = self.folders




        folders_owners = self.folders_owners




        groups: Union[Unset, List[str]] = UNSET
        if not isinstance(self.groups, Unset):
            groups = self.groups




        usage: Union[Unset, Dict[str, Any]] = UNSET
        if not isinstance(self.usage, Unset):
            usage = self.usage.to_dict()


        field_dict: Dict[str, Any] = {}
        field_dict.update(self.additional_properties)
        field_dict.update({
            "email": email,
            "username": username,
            "is_admin": is_admin,
            "is_super_admin": is_super_admin,
            "created_at": created_at,
            "operator": operator,
            "disabled": disabled,
            "folders": folders,
            "folders_owners": folders_owners,
        })
        if groups is not UNSET:
            field_dict["groups"] = groups
        if usage is not UNSET:
            field_dict["usage"] = usage

        return field_dict



    @classmethod
    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
        from ..models.user_usage import UserUsage
        d = src_dict.copy()
        email = d.pop("email")

        username = d.pop("username")

        is_admin = d.pop("is_admin")

        is_super_admin = d.pop("is_super_admin")

        created_at = isoparse(d.pop("created_at"))




        operator = d.pop("operator")

        disabled = d.pop("disabled")

        folders = cast(List[str], d.pop("folders"))


        folders_owners = cast(List[str], d.pop("folders_owners"))


        groups = cast(List[str], d.pop("groups", UNSET))


        _usage = d.pop("usage", UNSET)
        usage: Union[Unset, UserUsage]
        if isinstance(_usage,  Unset):
            usage = UNSET
        else:
            usage = UserUsage.from_dict(_usage)




        user = cls(
            email=email,
            username=username,
            is_admin=is_admin,
            is_super_admin=is_super_admin,
            created_at=created_at,
            operator=operator,
            disabled=disabled,
            folders=folders,
            folders_owners=folders_owners,
            groups=groups,
            usage=usage,
        )

        user.additional_properties = d
        return user

    @property
    def additional_keys(self) -> List[str]:
        return list(self.additional_properties.keys())

    def __getitem__(self, key: str) -> Any:
        return self.additional_properties[key]

    def __setitem__(self, key: str, value: Any) -> None:
        self.additional_properties[key] = value

    def __delitem__(self, key: str) -> None:
        del self.additional_properties[key]

    def __contains__(self, key: str) -> bool:
        return key in self.additional_properties