statuspro-openapi-client 0.1.0__py3-none-any.whl

statuspro_public_api_client/models/order_response.py

@@ -0,0 +1,220 @@
+from __future__ import annotations
+
+import datetime
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar, cast
+
+from attrs import (
+    define as _attrs_define,
+    field as _attrs_field,
+)
+from dateutil.parser import isoparse
+
+from ..client_types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.customer import Customer
+    from ..models.history_item import HistoryItem
+    from ..models.progress_timeline_item import ProgressTimelineItem
+    from ..models.status import Status
+
+
+T = TypeVar("T", bound="OrderResponse")
+
+
+@_attrs_define
+class OrderResponse:
+    id: int | Unset = UNSET
+    name: str | Unset = UNSET
+    order_number: str | Unset = UNSET
+    customer: Customer | Unset = UNSET
+    status: Status | Unset = UNSET
+    history: list[HistoryItem] | Unset = UNSET
+    public_progress_timeline: list[ProgressTimelineItem] | Unset = UNSET
+    due_date: datetime.datetime | None | Unset = UNSET
+    due_date_to: datetime.datetime | None | Unset = 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
+
+        order_number = self.order_number
+
+        customer: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.customer, Unset):
+            customer = self.customer.to_dict()
+
+        status: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.status, Unset):
+            status = self.status.to_dict()
+
+        history: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.history, Unset):
+            history = []
+            for history_item_data in self.history:
+                history_item = history_item_data.to_dict()
+                history.append(history_item)
+
+        public_progress_timeline: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.public_progress_timeline, Unset):
+            public_progress_timeline = []
+            for public_progress_timeline_item_data in self.public_progress_timeline:
+                public_progress_timeline_item = (
+                    public_progress_timeline_item_data.to_dict()
+                )
+                public_progress_timeline.append(public_progress_timeline_item)
+
+        due_date: None | str | Unset
+        if isinstance(self.due_date, Unset):
+            due_date = UNSET
+        elif isinstance(self.due_date, datetime.datetime):
+            due_date = self.due_date.isoformat()
+        else:
+            due_date = self.due_date
+
+        due_date_to: None | str | Unset
+        if isinstance(self.due_date_to, Unset):
+            due_date_to = UNSET
+        elif isinstance(self.due_date_to, datetime.datetime):
+            due_date_to = self.due_date_to.isoformat()
+        else:
+            due_date_to = self.due_date_to
+
+        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 order_number is not UNSET:
+            field_dict["order_number"] = order_number
+        if customer is not UNSET:
+            field_dict["customer"] = customer
+        if status is not UNSET:
+            field_dict["status"] = status
+        if history is not UNSET:
+            field_dict["history"] = history
+        if public_progress_timeline is not UNSET:
+            field_dict["public_progress_timeline"] = public_progress_timeline
+        if due_date is not UNSET:
+            field_dict["due_date"] = due_date
+        if due_date_to is not UNSET:
+            field_dict["due_date_to"] = due_date_to
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.customer import Customer
+        from ..models.history_item import HistoryItem
+        from ..models.progress_timeline_item import ProgressTimelineItem
+        from ..models.status import Status
+
+        d = dict(src_dict)
+        id = d.pop("id", UNSET)
+
+        name = d.pop("name", UNSET)
+
+        order_number = d.pop("order_number", UNSET)
+
+        _customer = d.pop("customer", UNSET)
+        customer: Customer | Unset
+        if isinstance(_customer, Unset):
+            customer = UNSET
+        else:
+            customer = Customer.from_dict(_customer)
+
+        _status = d.pop("status", UNSET)
+        status: Status | Unset
+        if isinstance(_status, Unset):
+            status = UNSET
+        else:
+            status = Status.from_dict(_status)
+
+        _history = d.pop("history", UNSET)
+        history: list[HistoryItem] | Unset = UNSET
+        if _history is not UNSET:
+            history = []
+            for history_item_data in _history:
+                history_item = HistoryItem.from_dict(history_item_data)
+
+                history.append(history_item)
+
+        _public_progress_timeline = d.pop("public_progress_timeline", UNSET)
+        public_progress_timeline: list[ProgressTimelineItem] | Unset = UNSET
+        if _public_progress_timeline is not UNSET:
+            public_progress_timeline = []
+            for public_progress_timeline_item_data in _public_progress_timeline:
+                public_progress_timeline_item = ProgressTimelineItem.from_dict(
+                    public_progress_timeline_item_data
+                )
+
+                public_progress_timeline.append(public_progress_timeline_item)
+
+        def _parse_due_date(data: object) -> datetime.datetime | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                due_date_type_0 = isoparse(data)
+
+                return due_date_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(datetime.datetime | None | Unset, data)
+
+        due_date = _parse_due_date(d.pop("due_date", UNSET))
+
+        def _parse_due_date_to(data: object) -> datetime.datetime | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                due_date_to_type_0 = isoparse(data)
+
+                return due_date_to_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(datetime.datetime | None | Unset, data)
+
+        due_date_to = _parse_due_date_to(d.pop("due_date_to", UNSET))
+
+        order_response = cls(
+            id=id,
+            name=name,
+            order_number=order_number,
+            customer=customer,
+            status=status,
+            history=history,
+            public_progress_timeline=public_progress_timeline,
+            due_date=due_date,
+            due_date_to=due_date_to,
+        )
+
+        order_response.additional_properties = d
+        return order_response
+
+    @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

statuspro_public_api_client/models/progress_timeline_item.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, cast
+
+from attrs import (
+    define as _attrs_define,
+    field as _attrs_field,
+)
+
+from ..client_types import UNSET, Unset
+
+T = TypeVar("T", bound="ProgressTimelineItem")
+
+
+@_attrs_define
+class ProgressTimelineItem:
+    name: str | Unset = UNSET
+    description: str | Unset = UNSET
+    progress: str | Unset = UNSET
+    timestamp: None | str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        name = self.name
+
+        description = self.description
+
+        progress = self.progress
+
+        timestamp: None | str | Unset
+        if isinstance(self.timestamp, Unset):
+            timestamp = UNSET
+        else:
+            timestamp = self.timestamp
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if name is not UNSET:
+            field_dict["name"] = name
+        if description is not UNSET:
+            field_dict["description"] = description
+        if progress is not UNSET:
+            field_dict["progress"] = progress
+        if timestamp is not UNSET:
+            field_dict["timestamp"] = timestamp
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        name = d.pop("name", UNSET)
+
+        description = d.pop("description", UNSET)
+
+        progress = d.pop("progress", UNSET)
+
+        def _parse_timestamp(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        timestamp = _parse_timestamp(d.pop("timestamp", UNSET))
+
+        progress_timeline_item = cls(
+            name=name,
+            description=description,
+            progress=progress,
+            timestamp=timestamp,
+        )
+
+        progress_timeline_item.additional_properties = d
+        return progress_timeline_item
+
+    @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

statuspro_public_api_client/models/set_due_date_request.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+import datetime
+from collections.abc import Mapping
+from typing import Any, TypeVar, cast
+
+from attrs import (
+    define as _attrs_define,
+    field as _attrs_field,
+)
+from dateutil.parser import isoparse
+
+from ..client_types import UNSET, Unset
+
+T = TypeVar("T", bound="SetDueDateRequest")
+
+
+@_attrs_define
+class SetDueDateRequest:
+    due_date: datetime.date | None
+    due_date_to: datetime.date | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        due_date: None | str
+        if isinstance(self.due_date, datetime.date):
+            due_date = self.due_date.isoformat()
+        else:
+            due_date = self.due_date
+
+        due_date_to: str | Unset = UNSET
+        if not isinstance(self.due_date_to, Unset):
+            due_date_to = self.due_date_to.isoformat()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "due_date": due_date,
+            }
+        )
+        if due_date_to is not UNSET:
+            field_dict["due_date_to"] = due_date_to
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+
+        def _parse_due_date(data: object) -> datetime.date | None:
+            if data is None:
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                due_date_type_0 = isoparse(data).date()
+
+                return due_date_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(datetime.date | None, data)
+
+        due_date = _parse_due_date(d.pop("due_date"))
+
+        _due_date_to = d.pop("due_date_to", UNSET)
+        due_date_to: datetime.date | Unset
+        if isinstance(_due_date_to, Unset):
+            due_date_to = UNSET
+        else:
+            due_date_to = isoparse(_due_date_to).date()
+
+        set_due_date_request = cls(
+            due_date=due_date,
+            due_date_to=due_date_to,
+        )
+
+        set_due_date_request.additional_properties = d
+        return set_due_date_request
+
+    @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

statuspro_public_api_client/models/status.py

@@ -0,0 +1,190 @@
+from __future__ import annotations
+
+import datetime
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar, cast
+
+from attrs import (
+    define as _attrs_define,
+    field as _attrs_field,
+)
+from dateutil.parser import isoparse
+
+from ..client_types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.status_translations import StatusTranslations
+
+
+T = TypeVar("T", bound="Status")
+
+
+@_attrs_define
+class Status:
+    is_set: bool | Unset = UNSET
+    code: str | Unset = UNSET
+    name: str | Unset = UNSET
+    public_name: None | str | Unset = UNSET
+    description: str | Unset = UNSET
+    public: bool | Unset = UNSET
+    set_at: datetime.datetime | None | Unset = UNSET
+    auto_change_at: datetime.datetime | None | Unset = UNSET
+    translations: StatusTranslations | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        is_set = self.is_set
+
+        code = self.code
+
+        name = self.name
+
+        public_name: None | str | Unset
+        if isinstance(self.public_name, Unset):
+            public_name = UNSET
+        else:
+            public_name = self.public_name
+
+        description = self.description
+
+        public = self.public
+
+        set_at: None | str | Unset
+        if isinstance(self.set_at, Unset):
+            set_at = UNSET
+        elif isinstance(self.set_at, datetime.datetime):
+            set_at = self.set_at.isoformat()
+        else:
+            set_at = self.set_at
+
+        auto_change_at: None | str | Unset
+        if isinstance(self.auto_change_at, Unset):
+            auto_change_at = UNSET
+        elif isinstance(self.auto_change_at, datetime.datetime):
+            auto_change_at = self.auto_change_at.isoformat()
+        else:
+            auto_change_at = self.auto_change_at
+
+        translations: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.translations, Unset):
+            translations = self.translations.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if is_set is not UNSET:
+            field_dict["is_set"] = is_set
+        if code is not UNSET:
+            field_dict["code"] = code
+        if name is not UNSET:
+            field_dict["name"] = name
+        if public_name is not UNSET:
+            field_dict["public_name"] = public_name
+        if description is not UNSET:
+            field_dict["description"] = description
+        if public is not UNSET:
+            field_dict["public"] = public
+        if set_at is not UNSET:
+            field_dict["set_at"] = set_at
+        if auto_change_at is not UNSET:
+            field_dict["auto_change_at"] = auto_change_at
+        if translations is not UNSET:
+            field_dict["translations"] = translations
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.status_translations import StatusTranslations
+
+        d = dict(src_dict)
+        is_set = d.pop("is_set", UNSET)
+
+        code = d.pop("code", UNSET)
+
+        name = d.pop("name", UNSET)
+
+        def _parse_public_name(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        public_name = _parse_public_name(d.pop("public_name", UNSET))
+
+        description = d.pop("description", UNSET)
+
+        public = d.pop("public", UNSET)
+
+        def _parse_set_at(data: object) -> datetime.datetime | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                set_at_type_0 = isoparse(data)
+
+                return set_at_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(datetime.datetime | None | Unset, data)
+
+        set_at = _parse_set_at(d.pop("set_at", UNSET))
+
+        def _parse_auto_change_at(data: object) -> datetime.datetime | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                auto_change_at_type_0 = isoparse(data)
+
+                return auto_change_at_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(datetime.datetime | None | Unset, data)
+
+        auto_change_at = _parse_auto_change_at(d.pop("auto_change_at", UNSET))
+
+        _translations = d.pop("translations", UNSET)
+        translations: StatusTranslations | Unset
+        if isinstance(_translations, Unset):
+            translations = UNSET
+        else:
+            translations = StatusTranslations.from_dict(_translations)
+
+        status = cls(
+            is_set=is_set,
+            code=code,
+            name=name,
+            public_name=public_name,
+            description=description,
+            public=public,
+            set_at=set_at,
+            auto_change_at=auto_change_at,
+            translations=translations,
+        )
+
+        status.additional_properties = d
+        return status
+
+    @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

statuspro_public_api_client/models/status_definition.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import (
+    define as _attrs_define,
+    field as _attrs_field,
+)
+
+from ..client_types import UNSET, Unset
+
+T = TypeVar("T", bound="StatusDefinition")
+
+
+@_attrs_define
+class StatusDefinition:
+    name: str | Unset = UNSET
+    description: str | Unset = UNSET
+    code: str | Unset = UNSET
+    color: str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        name = self.name
+
+        description = self.description
+
+        code = self.code
+
+        color = self.color
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if name is not UNSET:
+            field_dict["name"] = name
+        if description is not UNSET:
+            field_dict["description"] = description
+        if code is not UNSET:
+            field_dict["code"] = code
+        if color is not UNSET:
+            field_dict["color"] = color
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        name = d.pop("name", UNSET)
+
+        description = d.pop("description", UNSET)
+
+        code = d.pop("code", UNSET)
+
+        color = d.pop("color", UNSET)
+
+        status_definition = cls(
+            name=name,
+            description=description,
+            code=code,
+            color=color,
+        )
+
+        status_definition.additional_properties = d
+        return status_definition
+
+    @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