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

convexity_api_client/models/pick_pack_ship_picked_line_request.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+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 ..types import UNSET, Unset
+
+T = TypeVar("T", bound="PickPackShipPickedLineRequest")
+
+
+@_attrs_define
+class PickPackShipPickedLineRequest:
+    """
+    Attributes:
+        pick_ticket_line_id (str):
+        picked_quantity (float):
+        picked_stock_quantity (float | None | Unset):
+    """
+
+    pick_ticket_line_id: str
+    picked_quantity: float
+    picked_stock_quantity: float | None | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        pick_ticket_line_id = self.pick_ticket_line_id
+
+        picked_quantity = self.picked_quantity
+
+        picked_stock_quantity: float | None | Unset
+        if isinstance(self.picked_stock_quantity, Unset):
+            picked_stock_quantity = UNSET
+        else:
+            picked_stock_quantity = self.picked_stock_quantity
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "pick_ticket_line_id": pick_ticket_line_id,
+                "picked_quantity": picked_quantity,
+            }
+        )
+        if picked_stock_quantity is not UNSET:
+            field_dict["picked_stock_quantity"] = picked_stock_quantity
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        pick_ticket_line_id = d.pop("pick_ticket_line_id")
+
+        picked_quantity = d.pop("picked_quantity")
+
+        def _parse_picked_stock_quantity(data: object) -> float | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(float | None | Unset, data)
+
+        picked_stock_quantity = _parse_picked_stock_quantity(d.pop("picked_stock_quantity", UNSET))
+
+        pick_pack_ship_picked_line_request = cls(
+            pick_ticket_line_id=pick_ticket_line_id,
+            picked_quantity=picked_quantity,
+            picked_stock_quantity=picked_stock_quantity,
+        )
+
+        pick_pack_ship_picked_line_request.additional_properties = d
+        return pick_pack_ship_picked_line_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

convexity_api_client/models/pick_pack_ship_response.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.packing_slip_response import PackingSlipResponse
+    from ..models.pick_ticket_response import PickTicketResponse
+
+
+T = TypeVar("T", bound="PickPackShipResponse")
+
+
+@_attrs_define
+class PickPackShipResponse:
+    """Composite read model whose durable identity is ``packing_slip_id``.
+
+    Attributes:
+        packing_slip (PackingSlipResponse):
+        pick_ticket (PickTicketResponse):
+        shipment_id (None | str | Unset):
+        allowed_actions (list[str] | Unset):
+    """
+
+    packing_slip: PackingSlipResponse
+    pick_ticket: PickTicketResponse
+    shipment_id: None | str | Unset = UNSET
+    allowed_actions: list[str] | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        packing_slip = self.packing_slip.to_dict()
+
+        pick_ticket = self.pick_ticket.to_dict()
+
+        shipment_id: None | str | Unset
+        if isinstance(self.shipment_id, Unset):
+            shipment_id = UNSET
+        else:
+            shipment_id = self.shipment_id
+
+        allowed_actions: list[str] | Unset = UNSET
+        if not isinstance(self.allowed_actions, Unset):
+            allowed_actions = self.allowed_actions
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "packing_slip": packing_slip,
+                "pick_ticket": pick_ticket,
+            }
+        )
+        if shipment_id is not UNSET:
+            field_dict["shipment_id"] = shipment_id
+        if allowed_actions is not UNSET:
+            field_dict["allowed_actions"] = allowed_actions
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.packing_slip_response import PackingSlipResponse
+        from ..models.pick_ticket_response import PickTicketResponse
+
+        d = dict(src_dict)
+        packing_slip = PackingSlipResponse.from_dict(d.pop("packing_slip"))
+
+        pick_ticket = PickTicketResponse.from_dict(d.pop("pick_ticket"))
+
+        def _parse_shipment_id(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        shipment_id = _parse_shipment_id(d.pop("shipment_id", UNSET))
+
+        allowed_actions = cast(list[str], d.pop("allowed_actions", UNSET))
+
+        pick_pack_ship_response = cls(
+            packing_slip=packing_slip,
+            pick_ticket=pick_ticket,
+            shipment_id=shipment_id,
+            allowed_actions=allowed_actions,
+        )
+
+        pick_pack_ship_response.additional_properties = d
+        return pick_pack_ship_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/price_list.py

@@ -10,6 +10,7 @@ from attrs import field as _attrs_field
 from ..types import UNSET, Unset
 
 if TYPE_CHECKING:
+    from ..models.inventory_config import InventoryConfig
     from ..models.price_rule import PriceRule
     from ..models.project import Project
 
@@ -32,6 +33,7 @@ class PriceList:
         ext_data (None | str | Unset):
         project (None | Project | Unset):
         rules (list[PriceRule] | None | Unset):
+        default_for_config (list[InventoryConfig] | None | Unset):
     """
 
     id: str
@@ -44,6 +46,7 @@ class PriceList:
     ext_data: None | str | Unset = UNSET
     project: None | Project | Unset = UNSET
     rules: list[PriceRule] | None | Unset = UNSET
+    default_for_config: list[InventoryConfig] | None | Unset = UNSET
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
@@ -89,6 +92,18 @@ class PriceList:
         else:
             rules = self.rules
 
+        default_for_config: list[dict[str, Any]] | None | Unset
+        if isinstance(self.default_for_config, Unset):
+            default_for_config = UNSET
+        elif isinstance(self.default_for_config, list):
+            default_for_config = []
+            for default_for_config_type_0_item_data in self.default_for_config:
+                default_for_config_type_0_item = default_for_config_type_0_item_data.to_dict()
+                default_for_config.append(default_for_config_type_0_item)
+
+        else:
+            default_for_config = self.default_for_config
+
         field_dict: dict[str, Any] = {}
         field_dict.update(self.additional_properties)
         field_dict.update(
@@ -108,11 +123,14 @@ class PriceList:
             field_dict["project"] = project
         if rules is not UNSET:
             field_dict["rules"] = rules
+        if default_for_config is not UNSET:
+            field_dict["default_for_config"] = default_for_config
 
         return field_dict
 
     @classmethod
     def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.inventory_config import InventoryConfig
         from ..models.price_rule import PriceRule
         from ..models.project import Project
 
@@ -179,6 +197,28 @@ class PriceList:
 
         rules = _parse_rules(d.pop("rules", UNSET))
 
+        def _parse_default_for_config(data: object) -> list[InventoryConfig] | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, list):
+                    raise TypeError()
+                default_for_config_type_0 = []
+                _default_for_config_type_0 = data
+                for default_for_config_type_0_item_data in _default_for_config_type_0:
+                    default_for_config_type_0_item = InventoryConfig.from_dict(default_for_config_type_0_item_data)
+
+                    default_for_config_type_0.append(default_for_config_type_0_item)
+
+                return default_for_config_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(list[InventoryConfig] | None | Unset, data)
+
+        default_for_config = _parse_default_for_config(d.pop("default_for_config", UNSET))
+
         price_list = cls(
             id=id,
             project_id=project_id,
@@ -190,6 +230,7 @@ class PriceList:
             ext_data=ext_data,
             project=project,
             rules=rules,
+            default_for_config=default_for_config,
         )
 
         price_list.additional_properties = d

convexity_api_client/models/price_list_channel_assignment_response.py

@@ -0,0 +1,149 @@
+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
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+    from ..models.price_list_channel_assignment_response_ext_data_type_0 import (
+        PriceListChannelAssignmentResponseExtDataType0,
+    )
+
+
+T = TypeVar("T", bound="PriceListChannelAssignmentResponse")
+
+
+@_attrs_define
+class PriceListChannelAssignmentResponse:
+    """
+    Attributes:
+        id (str):
+        project_id (str):
+        price_list_id (str):
+        sales_channel_id (str):
+        is_active (bool):
+        ext_data (None | PriceListChannelAssignmentResponseExtDataType0):
+        created_at (datetime.datetime):
+        updated_at (datetime.datetime):
+    """
+
+    id: str
+    project_id: str
+    price_list_id: str
+    sales_channel_id: str
+    is_active: bool
+    ext_data: None | PriceListChannelAssignmentResponseExtDataType0
+    created_at: datetime.datetime
+    updated_at: datetime.datetime
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.price_list_channel_assignment_response_ext_data_type_0 import (
+            PriceListChannelAssignmentResponseExtDataType0,
+        )
+
+        id = self.id
+
+        project_id = self.project_id
+
+        price_list_id = self.price_list_id
+
+        sales_channel_id = self.sales_channel_id
+
+        is_active = self.is_active
+
+        ext_data: dict[str, Any] | None
+        if isinstance(self.ext_data, PriceListChannelAssignmentResponseExtDataType0):
+            ext_data = self.ext_data.to_dict()
+        else:
+            ext_data = self.ext_data
+
+        created_at = self.created_at.isoformat()
+
+        updated_at = self.updated_at.isoformat()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "id": id,
+                "project_id": project_id,
+                "price_list_id": price_list_id,
+                "sales_channel_id": sales_channel_id,
+                "is_active": is_active,
+                "ext_data": ext_data,
+                "created_at": created_at,
+                "updated_at": updated_at,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.price_list_channel_assignment_response_ext_data_type_0 import (
+            PriceListChannelAssignmentResponseExtDataType0,
+        )
+
+        d = dict(src_dict)
+        id = d.pop("id")
+
+        project_id = d.pop("project_id")
+
+        price_list_id = d.pop("price_list_id")
+
+        sales_channel_id = d.pop("sales_channel_id")
+
+        is_active = d.pop("is_active")
+
+        def _parse_ext_data(data: object) -> None | PriceListChannelAssignmentResponseExtDataType0:
+            if data is None:
+                return data
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                ext_data_type_0 = PriceListChannelAssignmentResponseExtDataType0.from_dict(data)
+
+                return ext_data_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(None | PriceListChannelAssignmentResponseExtDataType0, data)
+
+        ext_data = _parse_ext_data(d.pop("ext_data"))
+
+        created_at = datetime.datetime.fromisoformat(d.pop("created_at"))
+
+        updated_at = datetime.datetime.fromisoformat(d.pop("updated_at"))
+
+        price_list_channel_assignment_response = cls(
+            id=id,
+            project_id=project_id,
+            price_list_id=price_list_id,
+            sales_channel_id=sales_channel_id,
+            is_active=is_active,
+            ext_data=ext_data,
+            created_at=created_at,
+            updated_at=updated_at,
+        )
+
+        price_list_channel_assignment_response.additional_properties = d
+        return price_list_channel_assignment_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/price_list_channel_assignment_response_ext_data_type_0.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="PriceListChannelAssignmentResponseExtDataType0")
+
+
+@_attrs_define
+class PriceListChannelAssignmentResponseExtDataType0:
+    """ """
+
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        price_list_channel_assignment_response_ext_data_type_0 = cls()
+
+        price_list_channel_assignment_response_ext_data_type_0.additional_properties = d
+        return price_list_channel_assignment_response_ext_data_type_0
+
+    @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/price_list_customer_assignment_response.py

@@ -0,0 +1,149 @@
+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
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+    from ..models.price_list_customer_assignment_response_ext_data_type_0 import (
+        PriceListCustomerAssignmentResponseExtDataType0,
+    )
+
+
+T = TypeVar("T", bound="PriceListCustomerAssignmentResponse")
+
+
+@_attrs_define
+class PriceListCustomerAssignmentResponse:
+    """
+    Attributes:
+        id (str):
+        project_id (str):
+        price_list_id (str):
+        customer_id (str):
+        is_active (bool):
+        ext_data (None | PriceListCustomerAssignmentResponseExtDataType0):
+        created_at (datetime.datetime):
+        updated_at (datetime.datetime):
+    """
+
+    id: str
+    project_id: str
+    price_list_id: str
+    customer_id: str
+    is_active: bool
+    ext_data: None | PriceListCustomerAssignmentResponseExtDataType0
+    created_at: datetime.datetime
+    updated_at: datetime.datetime
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.price_list_customer_assignment_response_ext_data_type_0 import (
+            PriceListCustomerAssignmentResponseExtDataType0,
+        )
+
+        id = self.id
+
+        project_id = self.project_id
+
+        price_list_id = self.price_list_id
+
+        customer_id = self.customer_id
+
+        is_active = self.is_active
+
+        ext_data: dict[str, Any] | None
+        if isinstance(self.ext_data, PriceListCustomerAssignmentResponseExtDataType0):
+            ext_data = self.ext_data.to_dict()
+        else:
+            ext_data = self.ext_data
+
+        created_at = self.created_at.isoformat()
+
+        updated_at = self.updated_at.isoformat()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "id": id,
+                "project_id": project_id,
+                "price_list_id": price_list_id,
+                "customer_id": customer_id,
+                "is_active": is_active,
+                "ext_data": ext_data,
+                "created_at": created_at,
+                "updated_at": updated_at,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.price_list_customer_assignment_response_ext_data_type_0 import (
+            PriceListCustomerAssignmentResponseExtDataType0,
+        )
+
+        d = dict(src_dict)
+        id = d.pop("id")
+
+        project_id = d.pop("project_id")
+
+        price_list_id = d.pop("price_list_id")
+
+        customer_id = d.pop("customer_id")
+
+        is_active = d.pop("is_active")
+
+        def _parse_ext_data(data: object) -> None | PriceListCustomerAssignmentResponseExtDataType0:
+            if data is None:
+                return data
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                ext_data_type_0 = PriceListCustomerAssignmentResponseExtDataType0.from_dict(data)
+
+                return ext_data_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(None | PriceListCustomerAssignmentResponseExtDataType0, data)
+
+        ext_data = _parse_ext_data(d.pop("ext_data"))
+
+        created_at = datetime.datetime.fromisoformat(d.pop("created_at"))
+
+        updated_at = datetime.datetime.fromisoformat(d.pop("updated_at"))
+
+        price_list_customer_assignment_response = cls(
+            id=id,
+            project_id=project_id,
+            price_list_id=price_list_id,
+            customer_id=customer_id,
+            is_active=is_active,
+            ext_data=ext_data,
+            created_at=created_at,
+            updated_at=updated_at,
+        )
+
+        price_list_customer_assignment_response.additional_properties = d
+        return price_list_customer_assignment_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/price_list_customer_assignment_response_ext_data_type_0.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="PriceListCustomerAssignmentResponseExtDataType0")
+
+
+@_attrs_define
+class PriceListCustomerAssignmentResponseExtDataType0:
+    """ """
+
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        price_list_customer_assignment_response_ext_data_type_0 = cls()
+
+        price_list_customer_assignment_response_ext_data_type_0.additional_properties = d
+        return price_list_customer_assignment_response_ext_data_type_0
+
+    @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