Source code for pydelfini.delfini_core.models.session_user

from typing import Any
from typing import cast
from typing import Dict
from typing import List
from typing import Type
from typing import TypeVar
from typing import Union

from attrs import define as _attrs_define

from ..models.identity import Identity
from ..models.operations import Operations
from ..models.session_user_metadata import SessionUserMetadata
from ..types import UNSET
from ..types import Unset


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




@_attrs_define
class SessionUser:
    """SessionUser model

    Attributes:
        identity (Identity):
        metadata (SessionUserMetadata):
        name (str):
        account_id (Union[Unset, str]):
        email (Union[Unset, str]):
        has_operations (Union[Unset, List[Union[Operations, str]]]):
        image (Union[Unset, str]):
    """

    identity: "Identity"
    metadata: "SessionUserMetadata"
    name: str
    account_id: Union[Unset, str] = UNSET
    email: Union[Unset, str] = UNSET
    has_operations: Union[Unset, List[Union[Operations, str]]] = UNSET
    image: Union[Unset, str] = UNSET



    def to_dict(self) -> Dict[str, Any]:
        """Convert to a dict"""
        identity = self.identity.to_dict()
        metadata = self.metadata.to_dict()
        name = self.name
        account_id = self.account_id
        email = self.email
        has_operations: Union[Unset, List[str]] = UNSET
        if not isinstance(self.has_operations, Unset):
            has_operations = []
            for has_operations_item_data in self.has_operations:
                has_operations_item: str
                if isinstance(has_operations_item_data, Operations):
                    has_operations_item = has_operations_item_data.value
                else:
                    has_operations_item = has_operations_item_data
                has_operations.append(has_operations_item)

        image = self.image

        field_dict: Dict[str, Any] = {}
        field_dict.update(
            {
                "identity": identity,
                "metadata": metadata,
                "name": name,
            }
        )
        if account_id is not UNSET:
            field_dict["account_id"] = account_id
        if email is not UNSET:
            field_dict["email"] = email
        if has_operations is not UNSET:
            field_dict["has_operations"] = has_operations
        if image is not UNSET:
            field_dict["image"] = image

        return field_dict




    @classmethod
    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
        """Create an instance of :py:class:`SessionUser` from a dict"""
        d = src_dict.copy()
        identity = Identity.from_dict(d.pop("identity"))

        metadata = SessionUserMetadata.from_dict(d.pop("metadata"))

        name = d.pop("name")

        account_id = d.pop("account_id", UNSET)

        email = d.pop("email", UNSET)

        has_operations = []
        _has_operations = d.pop("has_operations", UNSET)
        for has_operations_item_data in _has_operations or []:

            def _parse_has_operations_item(data: object) -> Union[Operations, str]:
                try:
                    if not isinstance(data, str):
                        raise TypeError()
                    has_operations_item_type_0 = Operations(data)

                    return has_operations_item_type_0
                except:  # noqa: E722
                    pass
                return cast(Union[Operations, str], data)

            has_operations_item = _parse_has_operations_item(has_operations_item_data)

            has_operations.append(has_operations_item)

        image = d.pop("image", UNSET)

        session_user = cls(
            identity=identity,
            metadata=metadata,
            name=name,
            account_id=account_id,
            email=email,
            has_operations=has_operations,
            image=image,
        )

        return session_user