import datetime
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 dateutil.parser import isoparse
from ..models.group import Group
from ..models.user_admin import UserAdmin
from ..models.user_metadata import UserMetadata
from ..models.visibility_level import VisibilityLevel
from ..types import UNSET
from ..types import Unset
T = TypeVar("T", bound="User")
[docs]
@_attrs_define
class User:
"""User model
Attributes:
account_id (str):
created_on (datetime.datetime):
metadata (UserMetadata):
subject_id (str):
user_name (str):
visibility_level (VisibilityLevel):
admin (Union['UserAdmin', None, Unset]): Administrative settings. Populated only in the user listing for
requesters with admin.users; null otherwise.
given_name (Union[Unset, str]):
groups (Union[List['Group'], None, Unset]): Names and ids of the groups this user belongs to. Populated only in
the user listing for requesters with admin.users; null otherwise.
last_name (Union[Unset, str]):
user_email (Union[Unset, str]):
"""
account_id: str
created_on: datetime.datetime
metadata: "UserMetadata"
subject_id: str
user_name: str
visibility_level: VisibilityLevel
admin: Union["UserAdmin", None, Unset] = UNSET
given_name: Union[Unset, str] = UNSET
groups: Union[List["Group"], None, Unset] = UNSET
last_name: Union[Unset, str] = UNSET
user_email: Union[Unset, str] = UNSET
[docs]
def to_dict(self) -> Dict[str, Any]:
"""Convert to a dict"""
account_id = self.account_id
created_on = self.created_on.isoformat()
metadata = self.metadata.to_dict()
subject_id = self.subject_id
user_name = self.user_name
visibility_level = self.visibility_level.value
admin: Union[Dict[str, Any], None, Unset]
if isinstance(self.admin, Unset):
admin = UNSET
elif isinstance(self.admin, UserAdmin):
admin = self.admin.to_dict()
else:
admin = self.admin
given_name = self.given_name
groups: Union[List[Dict[str, Any]], None, Unset]
if isinstance(self.groups, Unset):
groups = UNSET
elif isinstance(self.groups, list):
groups = []
for groups_type_0_item_data in self.groups:
groups_type_0_item = groups_type_0_item_data.to_dict()
groups.append(groups_type_0_item)
else:
groups = self.groups
last_name = self.last_name
user_email = self.user_email
field_dict: Dict[str, Any] = {}
field_dict.update(
{
"account_id": account_id,
"created_on": created_on,
"metadata": metadata,
"subject_id": subject_id,
"user_name": user_name,
"visibility_level": visibility_level,
}
)
if admin is not UNSET:
field_dict["admin"] = admin
if given_name is not UNSET:
field_dict["given_name"] = given_name
if groups is not UNSET:
field_dict["groups"] = groups
if last_name is not UNSET:
field_dict["last_name"] = last_name
if user_email is not UNSET:
field_dict["user_email"] = user_email
return field_dict
[docs]
@classmethod
def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
"""Create an instance of :py:class:`User` from a dict"""
d = src_dict.copy()
account_id = d.pop("account_id")
created_on = isoparse(d.pop("created_on"))
metadata = UserMetadata.from_dict(d.pop("metadata"))
subject_id = d.pop("subject_id")
user_name = d.pop("user_name")
visibility_level = VisibilityLevel(d.pop("visibility_level"))
def _parse_admin(data: object) -> Union["UserAdmin", None, Unset]:
if data is None:
return data
if isinstance(data, Unset):
return data
try:
if not isinstance(data, dict):
raise TypeError()
admin_type_1 = UserAdmin.from_dict(data)
return admin_type_1
except: # noqa: E722
pass
return cast(Union["UserAdmin", None, Unset], data)
admin = _parse_admin(d.pop("admin", UNSET))
given_name = d.pop("given_name", UNSET)
def _parse_groups(data: object) -> Union[List["Group"], None, Unset]:
if data is None:
return data
if isinstance(data, Unset):
return data
try:
if not isinstance(data, list):
raise TypeError()
groups_type_0 = []
_groups_type_0 = data
for groups_type_0_item_data in _groups_type_0:
groups_type_0_item = Group.from_dict(groups_type_0_item_data)
groups_type_0.append(groups_type_0_item)
return groups_type_0
except: # noqa: E722
pass
return cast(Union[List["Group"], None, Unset], data)
groups = _parse_groups(d.pop("groups", UNSET))
last_name = d.pop("last_name", UNSET)
user_email = d.pop("user_email", UNSET)
user = cls(
account_id=account_id,
created_on=created_on,
metadata=metadata,
subject_id=subject_id,
user_name=user_name,
visibility_level=visibility_level,
admin=admin,
given_name=given_name,
groups=groups,
last_name=last_name,
user_email=user_email,
)
return user