import datetime from collections.abc import Mapping from typing import Any, TypeVar, Union, cast from attrs import define as _attrs_define from attrs import field as _attrs_field from dateutil.parser import isoparse from .. import types from ..models.privacy_level_enum import PrivacyLevelEnum from ..types import UNSET, Unset T = TypeVar("T", bound="PatchedUploadedImage") @_attrs_define class PatchedUploadedImage: """ Attributes: id (Union[Unset, int]): file (Union[Unset, str]): uploaded_at (Union[Unset, datetime.datetime]): the datetime the image was uploaded at event (Union[None, Unset, int]): the event associated to the image frontend_login (Union[None, Unset, int]): the frontendlogin who uploaded the image user (Union[None, Unset, int]): the user who uploaded the image privacy_level (Union[Unset, PrivacyLevelEnum]): * `public` - Public * `event` - Event * `personal` - Personal """ id: Union[Unset, int] = UNSET file: Union[Unset, str] = UNSET uploaded_at: Union[Unset, datetime.datetime] = UNSET event: Union[None, Unset, int] = UNSET frontend_login: Union[None, Unset, int] = UNSET user: Union[None, Unset, int] = UNSET privacy_level: Union[Unset, PrivacyLevelEnum] = UNSET additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict) def to_dict(self) -> dict[str, Any]: id = self.id file = self.file uploaded_at: Union[Unset, str] = UNSET if not isinstance(self.uploaded_at, Unset): uploaded_at = self.uploaded_at.isoformat() event: Union[None, Unset, int] if isinstance(self.event, Unset): event = UNSET else: event = self.event frontend_login: Union[None, Unset, int] if isinstance(self.frontend_login, Unset): frontend_login = UNSET else: frontend_login = self.frontend_login user: Union[None, Unset, int] if isinstance(self.user, Unset): user = UNSET else: user = self.user privacy_level: Union[Unset, str] = UNSET if not isinstance(self.privacy_level, Unset): privacy_level = self.privacy_level.value field_dict: dict[str, Any] = {} field_dict.update(self.additional_properties) field_dict.update({}) if id is not UNSET: field_dict["id"] = id if file is not UNSET: field_dict["file"] = file if uploaded_at is not UNSET: field_dict["uploaded_at"] = uploaded_at if event is not UNSET: field_dict["event"] = event if frontend_login is not UNSET: field_dict["frontend_login"] = frontend_login if user is not UNSET: field_dict["user"] = user if privacy_level is not UNSET: field_dict["privacy_level"] = privacy_level return field_dict def to_multipart(self) -> types.RequestFiles: files: types.RequestFiles = [] if not isinstance(self.id, Unset): files.append(("id", (None, str(self.id).encode(), "text/plain"))) if not isinstance(self.file, Unset): files.append(("file", (None, str(self.file).encode(), "text/plain"))) if not isinstance(self.uploaded_at, Unset): files.append(("uploaded_at", (None, self.uploaded_at.isoformat().encode(), "text/plain"))) if not isinstance(self.event, Unset): if isinstance(self.event, int): files.append(("event", (None, str(self.event).encode(), "text/plain"))) else: files.append(("event", (None, str(self.event).encode(), "text/plain"))) if not isinstance(self.frontend_login, Unset): if isinstance(self.frontend_login, int): files.append(("frontend_login", (None, str(self.frontend_login).encode(), "text/plain"))) else: files.append(("frontend_login", (None, str(self.frontend_login).encode(), "text/plain"))) if not isinstance(self.user, Unset): if isinstance(self.user, int): files.append(("user", (None, str(self.user).encode(), "text/plain"))) else: files.append(("user", (None, str(self.user).encode(), "text/plain"))) if not isinstance(self.privacy_level, Unset): files.append(("privacy_level", (None, str(self.privacy_level.value).encode(), "text/plain"))) for prop_name, prop in self.additional_properties.items(): files.append((prop_name, (None, str(prop).encode(), "text/plain"))) return files @classmethod def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T: d = dict(src_dict) id = d.pop("id", UNSET) file = d.pop("file", UNSET) _uploaded_at = d.pop("uploaded_at", UNSET) uploaded_at: Union[Unset, datetime.datetime] if isinstance(_uploaded_at, Unset): uploaded_at = UNSET else: uploaded_at = isoparse(_uploaded_at) def _parse_event(data: object) -> Union[None, Unset, int]: if data is None: return data if isinstance(data, Unset): return data return cast(Union[None, Unset, int], data) event = _parse_event(d.pop("event", UNSET)) def _parse_frontend_login(data: object) -> Union[None, Unset, int]: if data is None: return data if isinstance(data, Unset): return data return cast(Union[None, Unset, int], data) frontend_login = _parse_frontend_login(d.pop("frontend_login", UNSET)) def _parse_user(data: object) -> Union[None, Unset, int]: if data is None: return data if isinstance(data, Unset): return data return cast(Union[None, Unset, int], data) user = _parse_user(d.pop("user", UNSET)) _privacy_level = d.pop("privacy_level", UNSET) privacy_level: Union[Unset, PrivacyLevelEnum] if isinstance(_privacy_level, Unset): privacy_level = UNSET else: privacy_level = PrivacyLevelEnum(_privacy_level) patched_uploaded_image = cls( id=id, file=file, uploaded_at=uploaded_at, event=event, frontend_login=frontend_login, user=user, privacy_level=privacy_level, ) patched_uploaded_image.additional_properties = d return patched_uploaded_image @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