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 ..types import UNSET, Unset T = TypeVar("T", bound="PatchedNodeAvailability") @_attrs_define class PatchedNodeAvailability: """Serializer (read/write) for NodeAvailability model Attributes: id (Union[Unset, int]): name (Union[Unset, str]): node_configuration_ids (Union[Unset, list[int]]): condition_id (Union[Unset, int]): starts_at (Union[None, Unset, datetime.datetime]): ends_at (Union[None, Unset, datetime.datetime]): event (Union[Unset, int]): event_id (Union[Unset, int]): """ id: Union[Unset, int] = UNSET name: Union[Unset, str] = UNSET node_configuration_ids: Union[Unset, list[int]] = UNSET condition_id: Union[Unset, int] = UNSET starts_at: Union[None, Unset, datetime.datetime] = UNSET ends_at: Union[None, Unset, datetime.datetime] = UNSET event: Union[Unset, int] = UNSET event_id: Union[Unset, int] = UNSET additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict) def to_dict(self) -> dict[str, Any]: id = self.id name = self.name node_configuration_ids: Union[Unset, list[int]] = UNSET if not isinstance(self.node_configuration_ids, Unset): node_configuration_ids = self.node_configuration_ids condition_id = self.condition_id starts_at: Union[None, Unset, str] if isinstance(self.starts_at, Unset): starts_at = UNSET elif isinstance(self.starts_at, datetime.datetime): starts_at = self.starts_at.isoformat() else: starts_at = self.starts_at ends_at: Union[None, Unset, str] if isinstance(self.ends_at, Unset): ends_at = UNSET elif isinstance(self.ends_at, datetime.datetime): ends_at = self.ends_at.isoformat() else: ends_at = self.ends_at event = self.event event_id = self.event_id field_dict: dict[str, Any] = {} field_dict.update(self.additional_properties) field_dict.update({}) if id is not UNSET: field_dict["id"] = id if name is not UNSET: field_dict["name"] = name if node_configuration_ids is not UNSET: field_dict["node_configuration_ids"] = node_configuration_ids if condition_id is not UNSET: field_dict["condition_id"] = condition_id if starts_at is not UNSET: field_dict["starts_at"] = starts_at if ends_at is not UNSET: field_dict["ends_at"] = ends_at if event is not UNSET: field_dict["event"] = event if event_id is not UNSET: field_dict["event_id"] = event_id 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.name, Unset): files.append(("name", (None, str(self.name).encode(), "text/plain"))) if not isinstance(self.node_configuration_ids, Unset): for node_configuration_ids_item_element in self.node_configuration_ids: files.append( ("node_configuration_ids", (None, str(node_configuration_ids_item_element).encode(), "text/plain")) ) if not isinstance(self.condition_id, Unset): files.append(("condition_id", (None, str(self.condition_id).encode(), "text/plain"))) if not isinstance(self.starts_at, Unset): if isinstance(self.starts_at, datetime.datetime): files.append(("starts_at", (None, self.starts_at.isoformat().encode(), "text/plain"))) else: files.append(("starts_at", (None, str(self.starts_at).encode(), "text/plain"))) if not isinstance(self.ends_at, Unset): if isinstance(self.ends_at, datetime.datetime): files.append(("ends_at", (None, self.ends_at.isoformat().encode(), "text/plain"))) else: files.append(("ends_at", (None, str(self.ends_at).encode(), "text/plain"))) if not isinstance(self.event, Unset): files.append(("event", (None, str(self.event).encode(), "text/plain"))) if not isinstance(self.event_id, Unset): files.append(("event_id", (None, str(self.event_id).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) name = d.pop("name", UNSET) node_configuration_ids = cast(list[int], d.pop("node_configuration_ids", UNSET)) condition_id = d.pop("condition_id", UNSET) def _parse_starts_at(data: object) -> Union[None, Unset, datetime.datetime]: if data is None: return data if isinstance(data, Unset): return data try: if not isinstance(data, str): raise TypeError() starts_at_type_0 = isoparse(data) return starts_at_type_0 except: # noqa: E722 pass return cast(Union[None, Unset, datetime.datetime], data) starts_at = _parse_starts_at(d.pop("starts_at", UNSET)) def _parse_ends_at(data: object) -> Union[None, Unset, datetime.datetime]: if data is None: return data if isinstance(data, Unset): return data try: if not isinstance(data, str): raise TypeError() ends_at_type_0 = isoparse(data) return ends_at_type_0 except: # noqa: E722 pass return cast(Union[None, Unset, datetime.datetime], data) ends_at = _parse_ends_at(d.pop("ends_at", UNSET)) event = d.pop("event", UNSET) event_id = d.pop("event_id", UNSET) patched_node_availability = cls( id=id, name=name, node_configuration_ids=node_configuration_ids, condition_id=condition_id, starts_at=starts_at, ends_at=ends_at, event=event, event_id=event_id, ) patched_node_availability.additional_properties = d return patched_node_availability @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