convexity-api-client 0.21.0.dev332__py3-none-any.whl → 0.21.0.dev336__py3-none-any.whl

convexity_api_client/models/item_warehouse_location_response.py

@@ -0,0 +1,248 @@
+from __future__ import annotations
+
+import datetime
+from collections.abc import Mapping
+from typing import Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.location_kind import LocationKind
+from ..models.location_type import LocationType
+
+T = TypeVar("T", bound="ItemWarehouseLocationResponse")
+
+
+@_attrs_define
+class ItemWarehouseLocationResponse:
+    """A warehouse location assigned to or currently stocking an item.
+
+    Attributes:
+        warehouse_id (str):
+        warehouse_code (str):
+        warehouse_name (str):
+        warehouse_location_id (str):
+        parent_id (None | str):
+        location_name (str):
+        location_code (None | str):
+        location_type (LocationType):
+        location_kind (LocationKind | None):
+        location_path (str):
+        location_depth (int):
+        is_assigned (bool):
+        on_hand_qty (float):
+        available_qty (float):
+        reserved_qty (float):
+        on_order_qty (float):
+        in_transit_qty (float):
+        last_transaction_at (datetime.datetime | None):
+    """
+
+    warehouse_id: str
+    warehouse_code: str
+    warehouse_name: str
+    warehouse_location_id: str
+    parent_id: None | str
+    location_name: str
+    location_code: None | str
+    location_type: LocationType
+    location_kind: LocationKind | None
+    location_path: str
+    location_depth: int
+    is_assigned: bool
+    on_hand_qty: float
+    available_qty: float
+    reserved_qty: float
+    on_order_qty: float
+    in_transit_qty: float
+    last_transaction_at: datetime.datetime | None
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        warehouse_id = self.warehouse_id
+
+        warehouse_code = self.warehouse_code
+
+        warehouse_name = self.warehouse_name
+
+        warehouse_location_id = self.warehouse_location_id
+
+        parent_id: None | str
+        parent_id = self.parent_id
+
+        location_name = self.location_name
+
+        location_code: None | str
+        location_code = self.location_code
+
+        location_type = self.location_type.value
+
+        location_kind: None | str
+        if isinstance(self.location_kind, LocationKind):
+            location_kind = self.location_kind.value
+        else:
+            location_kind = self.location_kind
+
+        location_path = self.location_path
+
+        location_depth = self.location_depth
+
+        is_assigned = self.is_assigned
+
+        on_hand_qty = self.on_hand_qty
+
+        available_qty = self.available_qty
+
+        reserved_qty = self.reserved_qty
+
+        on_order_qty = self.on_order_qty
+
+        in_transit_qty = self.in_transit_qty
+
+        last_transaction_at: None | str
+        if isinstance(self.last_transaction_at, datetime.datetime):
+            last_transaction_at = self.last_transaction_at.isoformat()
+        else:
+            last_transaction_at = self.last_transaction_at
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "warehouse_id": warehouse_id,
+                "warehouse_code": warehouse_code,
+                "warehouse_name": warehouse_name,
+                "warehouse_location_id": warehouse_location_id,
+                "parent_id": parent_id,
+                "location_name": location_name,
+                "location_code": location_code,
+                "location_type": location_type,
+                "location_kind": location_kind,
+                "location_path": location_path,
+                "location_depth": location_depth,
+                "is_assigned": is_assigned,
+                "on_hand_qty": on_hand_qty,
+                "available_qty": available_qty,
+                "reserved_qty": reserved_qty,
+                "on_order_qty": on_order_qty,
+                "in_transit_qty": in_transit_qty,
+                "last_transaction_at": last_transaction_at,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        warehouse_id = d.pop("warehouse_id")
+
+        warehouse_code = d.pop("warehouse_code")
+
+        warehouse_name = d.pop("warehouse_name")
+
+        warehouse_location_id = d.pop("warehouse_location_id")
+
+        def _parse_parent_id(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        parent_id = _parse_parent_id(d.pop("parent_id"))
+
+        location_name = d.pop("location_name")
+
+        def _parse_location_code(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        location_code = _parse_location_code(d.pop("location_code"))
+
+        location_type = LocationType(d.pop("location_type"))
+
+        def _parse_location_kind(data: object) -> LocationKind | None:
+            if data is None:
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                location_kind_type_0 = LocationKind(data)
+
+                return location_kind_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(LocationKind | None, data)
+
+        location_kind = _parse_location_kind(d.pop("location_kind"))
+
+        location_path = d.pop("location_path")
+
+        location_depth = d.pop("location_depth")
+
+        is_assigned = d.pop("is_assigned")
+
+        on_hand_qty = d.pop("on_hand_qty")
+
+        available_qty = d.pop("available_qty")
+
+        reserved_qty = d.pop("reserved_qty")
+
+        on_order_qty = d.pop("on_order_qty")
+
+        in_transit_qty = d.pop("in_transit_qty")
+
+        def _parse_last_transaction_at(data: object) -> datetime.datetime | None:
+            if data is None:
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                last_transaction_at_type_0 = datetime.datetime.fromisoformat(data)
+
+                return last_transaction_at_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(datetime.datetime | None, data)
+
+        last_transaction_at = _parse_last_transaction_at(d.pop("last_transaction_at"))
+
+        item_warehouse_location_response = cls(
+            warehouse_id=warehouse_id,
+            warehouse_code=warehouse_code,
+            warehouse_name=warehouse_name,
+            warehouse_location_id=warehouse_location_id,
+            parent_id=parent_id,
+            location_name=location_name,
+            location_code=location_code,
+            location_type=location_type,
+            location_kind=location_kind,
+            location_path=location_path,
+            location_depth=location_depth,
+            is_assigned=is_assigned,
+            on_hand_qty=on_hand_qty,
+            available_qty=available_qty,
+            reserved_qty=reserved_qty,
+            on_order_qty=on_order_qty,
+            in_transit_qty=in_transit_qty,
+            last_transaction_at=last_transaction_at,
+        )
+
+        item_warehouse_location_response.additional_properties = d
+        return item_warehouse_location_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

convexity_api_client/models/list_cost_list_entries_response.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+    from ..models.cost_list_entry_response import CostListEntryResponse
+
+
+T = TypeVar("T", bound="ListCostListEntriesResponse")
+
+
+@_attrs_define
+class ListCostListEntriesResponse:
+    """
+    Attributes:
+        entries (list[CostListEntryResponse]):
+        total (int):
+    """
+
+    entries: list[CostListEntryResponse]
+    total: int
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        entries = []
+        for entries_item_data in self.entries:
+            entries_item = entries_item_data.to_dict()
+            entries.append(entries_item)
+
+        total = self.total
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "entries": entries,
+                "total": total,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.cost_list_entry_response import CostListEntryResponse
+
+        d = dict(src_dict)
+        entries = []
+        _entries = d.pop("entries")
+        for entries_item_data in _entries:
+            entries_item = CostListEntryResponse.from_dict(entries_item_data)
+
+            entries.append(entries_item)
+
+        total = d.pop("total")
+
+        list_cost_list_entries_response = cls(
+            entries=entries,
+            total=total,
+        )
+
+        list_cost_list_entries_response.additional_properties = d
+        return list_cost_list_entries_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

convexity_api_client/models/list_cost_list_vendor_assignments_response.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+    from ..models.cost_list_vendor_assignment_response import CostListVendorAssignmentResponse
+
+
+T = TypeVar("T", bound="ListCostListVendorAssignmentsResponse")
+
+
+@_attrs_define
+class ListCostListVendorAssignmentsResponse:
+    """
+    Attributes:
+        assignments (list[CostListVendorAssignmentResponse]):
+        total (int):
+    """
+
+    assignments: list[CostListVendorAssignmentResponse]
+    total: int
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        assignments = []
+        for assignments_item_data in self.assignments:
+            assignments_item = assignments_item_data.to_dict()
+            assignments.append(assignments_item)
+
+        total = self.total
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "assignments": assignments,
+                "total": total,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.cost_list_vendor_assignment_response import CostListVendorAssignmentResponse
+
+        d = dict(src_dict)
+        assignments = []
+        _assignments = d.pop("assignments")
+        for assignments_item_data in _assignments:
+            assignments_item = CostListVendorAssignmentResponse.from_dict(assignments_item_data)
+
+            assignments.append(assignments_item)
+
+        total = d.pop("total")
+
+        list_cost_list_vendor_assignments_response = cls(
+            assignments=assignments,
+            total=total,
+        )
+
+        list_cost_list_vendor_assignments_response.additional_properties = d
+        return list_cost_list_vendor_assignments_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

convexity_api_client/models/list_item_sourcing_response.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+    from ..models.item_sourcing_response import ItemSourcingResponse
+
+
+T = TypeVar("T", bound="ListItemSourcingResponse")
+
+
+@_attrs_define
+class ListItemSourcingResponse:
+    """
+    Attributes:
+        sourcing (list[ItemSourcingResponse]):
+        total (int):
+    """
+
+    sourcing: list[ItemSourcingResponse]
+    total: int
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        sourcing = []
+        for sourcing_item_data in self.sourcing:
+            sourcing_item = sourcing_item_data.to_dict()
+            sourcing.append(sourcing_item)
+
+        total = self.total
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "sourcing": sourcing,
+                "total": total,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.item_sourcing_response import ItemSourcingResponse
+
+        d = dict(src_dict)
+        sourcing = []
+        _sourcing = d.pop("sourcing")
+        for sourcing_item_data in _sourcing:
+            sourcing_item = ItemSourcingResponse.from_dict(sourcing_item_data)
+
+            sourcing.append(sourcing_item)
+
+        total = d.pop("total")
+
+        list_item_sourcing_response = cls(
+            sourcing=sourcing,
+            total=total,
+        )
+
+        list_item_sourcing_response.additional_properties = d
+        return list_item_sourcing_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

convexity_api_client/models/list_item_warehouse_locations_response.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+    from ..models.item_warehouse_location_response import ItemWarehouseLocationResponse
+
+
+T = TypeVar("T", bound="ListItemWarehouseLocationsResponse")
+
+
+@_attrs_define
+class ListItemWarehouseLocationsResponse:
+    """
+    Attributes:
+        items (list[ItemWarehouseLocationResponse]):
+        total (int):
+    """
+
+    items: list[ItemWarehouseLocationResponse]
+    total: int
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        items = []
+        for items_item_data in self.items:
+            items_item = items_item_data.to_dict()
+            items.append(items_item)
+
+        total = self.total
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "items": items,
+                "total": total,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.item_warehouse_location_response import ItemWarehouseLocationResponse
+
+        d = dict(src_dict)
+        items = []
+        _items = d.pop("items")
+        for items_item_data in _items:
+            items_item = ItemWarehouseLocationResponse.from_dict(items_item_data)
+
+            items.append(items_item)
+
+        total = d.pop("total")
+
+        list_item_warehouse_locations_response = cls(
+            items=items,
+            total=total,
+        )
+
+        list_item_warehouse_locations_response.additional_properties = d
+        return list_item_warehouse_locations_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

convexity_api_client/models/list_price_list_channel_assignments_response.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+    from ..models.price_list_channel_assignment_response import PriceListChannelAssignmentResponse
+
+
+T = TypeVar("T", bound="ListPriceListChannelAssignmentsResponse")
+
+
+@_attrs_define
+class ListPriceListChannelAssignmentsResponse:
+    """
+    Attributes:
+        assignments (list[PriceListChannelAssignmentResponse]):
+        total (int):
+    """
+
+    assignments: list[PriceListChannelAssignmentResponse]
+    total: int
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        assignments = []
+        for assignments_item_data in self.assignments:
+            assignments_item = assignments_item_data.to_dict()
+            assignments.append(assignments_item)
+
+        total = self.total
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "assignments": assignments,
+                "total": total,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.price_list_channel_assignment_response import PriceListChannelAssignmentResponse
+
+        d = dict(src_dict)
+        assignments = []
+        _assignments = d.pop("assignments")
+        for assignments_item_data in _assignments:
+            assignments_item = PriceListChannelAssignmentResponse.from_dict(assignments_item_data)
+
+            assignments.append(assignments_item)
+
+        total = d.pop("total")
+
+        list_price_list_channel_assignments_response = cls(
+            assignments=assignments,
+            total=total,
+        )
+
+        list_price_list_channel_assignments_response.additional_properties = d
+        return list_price_list_channel_assignments_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