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

convexity_api_client/models/item_sourcing_options_response.py

@@ -0,0 +1,120 @@
+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
+
+if TYPE_CHECKING:
+    from ..models.item_sourcing_item_option import ItemSourcingItemOption
+    from ..models.item_sourcing_uom_option import ItemSourcingUomOption
+    from ..models.item_sourcing_vendor_option import ItemSourcingVendorOption
+
+
+T = TypeVar("T", bound="ItemSourcingOptionsResponse")
+
+
+@_attrs_define
+class ItemSourcingOptionsResponse:
+    """Project-owned values used by the sourcing table's inline selectors.
+
+    Attributes:
+        items (list[ItemSourcingItemOption]):
+        vendors (list[ItemSourcingVendorOption]):
+        uoms (list[ItemSourcingUomOption]):
+        origin_country_codes (list[str]):
+    """
+
+    items: list[ItemSourcingItemOption]
+    vendors: list[ItemSourcingVendorOption]
+    uoms: list[ItemSourcingUomOption]
+    origin_country_codes: list[str]
+    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)
+
+        vendors = []
+        for vendors_item_data in self.vendors:
+            vendors_item = vendors_item_data.to_dict()
+            vendors.append(vendors_item)
+
+        uoms = []
+        for uoms_item_data in self.uoms:
+            uoms_item = uoms_item_data.to_dict()
+            uoms.append(uoms_item)
+
+        origin_country_codes = self.origin_country_codes
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "items": items,
+                "vendors": vendors,
+                "uoms": uoms,
+                "origin_country_codes": origin_country_codes,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.item_sourcing_item_option import ItemSourcingItemOption
+        from ..models.item_sourcing_uom_option import ItemSourcingUomOption
+        from ..models.item_sourcing_vendor_option import ItemSourcingVendorOption
+
+        d = dict(src_dict)
+        items = []
+        _items = d.pop("items")
+        for items_item_data in _items:
+            items_item = ItemSourcingItemOption.from_dict(items_item_data)
+
+            items.append(items_item)
+
+        vendors = []
+        _vendors = d.pop("vendors")
+        for vendors_item_data in _vendors:
+            vendors_item = ItemSourcingVendorOption.from_dict(vendors_item_data)
+
+            vendors.append(vendors_item)
+
+        uoms = []
+        _uoms = d.pop("uoms")
+        for uoms_item_data in _uoms:
+            uoms_item = ItemSourcingUomOption.from_dict(uoms_item_data)
+
+            uoms.append(uoms_item)
+
+        origin_country_codes = cast(list[str], d.pop("origin_country_codes"))
+
+        item_sourcing_options_response = cls(
+            items=items,
+            vendors=vendors,
+            uoms=uoms,
+            origin_country_codes=origin_country_codes,
+        )
+
+        item_sourcing_options_response.additional_properties = d
+        return item_sourcing_options_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/item_sourcing_response.py

@@ -0,0 +1,360 @@
+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.item_sourcing_response_ext_data_type_0 import ItemSourcingResponseExtDataType0
+
+
+T = TypeVar("T", bound="ItemSourcingResponse")
+
+
+@_attrs_define
+class ItemSourcingResponse:
+    """Sourcing row with the display data required by the purchasing table.
+
+    Attributes:
+        id (str):
+        project_id (str):
+        inventory_item_id (str):
+        item_sku (str):
+        item_name (str):
+        vendor_id (str):
+        vendor_code (str):
+        vendor_name (str):
+        vendor_item_code (None | str):
+        origin_country_code (str):
+        hts_code (None | str):
+        uom_id (None | str):
+        uom_code (None | str):
+        uom_name (None | str):
+        min_order_qty (float | None):
+        order_multiple_qty (float | None):
+        lead_time_days (int | None):
+        unit_cost (float | None):
+        cost_currency (None | str):
+        cost_list_id (None | str):
+        cost_rule_id (None | str):
+        is_primary (bool):
+        is_active (bool):
+        ext_data (ItemSourcingResponseExtDataType0 | None):
+        created_at (datetime.datetime):
+        updated_at (datetime.datetime):
+    """
+
+    id: str
+    project_id: str
+    inventory_item_id: str
+    item_sku: str
+    item_name: str
+    vendor_id: str
+    vendor_code: str
+    vendor_name: str
+    vendor_item_code: None | str
+    origin_country_code: str
+    hts_code: None | str
+    uom_id: None | str
+    uom_code: None | str
+    uom_name: None | str
+    min_order_qty: float | None
+    order_multiple_qty: float | None
+    lead_time_days: int | None
+    unit_cost: float | None
+    cost_currency: None | str
+    cost_list_id: None | str
+    cost_rule_id: None | str
+    is_primary: bool
+    is_active: bool
+    ext_data: ItemSourcingResponseExtDataType0 | None
+    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.item_sourcing_response_ext_data_type_0 import ItemSourcingResponseExtDataType0
+
+        id = self.id
+
+        project_id = self.project_id
+
+        inventory_item_id = self.inventory_item_id
+
+        item_sku = self.item_sku
+
+        item_name = self.item_name
+
+        vendor_id = self.vendor_id
+
+        vendor_code = self.vendor_code
+
+        vendor_name = self.vendor_name
+
+        vendor_item_code: None | str
+        vendor_item_code = self.vendor_item_code
+
+        origin_country_code = self.origin_country_code
+
+        hts_code: None | str
+        hts_code = self.hts_code
+
+        uom_id: None | str
+        uom_id = self.uom_id
+
+        uom_code: None | str
+        uom_code = self.uom_code
+
+        uom_name: None | str
+        uom_name = self.uom_name
+
+        min_order_qty: float | None
+        min_order_qty = self.min_order_qty
+
+        order_multiple_qty: float | None
+        order_multiple_qty = self.order_multiple_qty
+
+        lead_time_days: int | None
+        lead_time_days = self.lead_time_days
+
+        unit_cost: float | None
+        unit_cost = self.unit_cost
+
+        cost_currency: None | str
+        cost_currency = self.cost_currency
+
+        cost_list_id: None | str
+        cost_list_id = self.cost_list_id
+
+        cost_rule_id: None | str
+        cost_rule_id = self.cost_rule_id
+
+        is_primary = self.is_primary
+
+        is_active = self.is_active
+
+        ext_data: dict[str, Any] | None
+        if isinstance(self.ext_data, ItemSourcingResponseExtDataType0):
+            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,
+                "inventory_item_id": inventory_item_id,
+                "item_sku": item_sku,
+                "item_name": item_name,
+                "vendor_id": vendor_id,
+                "vendor_code": vendor_code,
+                "vendor_name": vendor_name,
+                "vendor_item_code": vendor_item_code,
+                "origin_country_code": origin_country_code,
+                "hts_code": hts_code,
+                "uom_id": uom_id,
+                "uom_code": uom_code,
+                "uom_name": uom_name,
+                "min_order_qty": min_order_qty,
+                "order_multiple_qty": order_multiple_qty,
+                "lead_time_days": lead_time_days,
+                "unit_cost": unit_cost,
+                "cost_currency": cost_currency,
+                "cost_list_id": cost_list_id,
+                "cost_rule_id": cost_rule_id,
+                "is_primary": is_primary,
+                "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.item_sourcing_response_ext_data_type_0 import ItemSourcingResponseExtDataType0
+
+        d = dict(src_dict)
+        id = d.pop("id")
+
+        project_id = d.pop("project_id")
+
+        inventory_item_id = d.pop("inventory_item_id")
+
+        item_sku = d.pop("item_sku")
+
+        item_name = d.pop("item_name")
+
+        vendor_id = d.pop("vendor_id")
+
+        vendor_code = d.pop("vendor_code")
+
+        vendor_name = d.pop("vendor_name")
+
+        def _parse_vendor_item_code(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        vendor_item_code = _parse_vendor_item_code(d.pop("vendor_item_code"))
+
+        origin_country_code = d.pop("origin_country_code")
+
+        def _parse_hts_code(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        hts_code = _parse_hts_code(d.pop("hts_code"))
+
+        def _parse_uom_id(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        uom_id = _parse_uom_id(d.pop("uom_id"))
+
+        def _parse_uom_code(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        uom_code = _parse_uom_code(d.pop("uom_code"))
+
+        def _parse_uom_name(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        uom_name = _parse_uom_name(d.pop("uom_name"))
+
+        def _parse_min_order_qty(data: object) -> float | None:
+            if data is None:
+                return data
+            return cast(float | None, data)
+
+        min_order_qty = _parse_min_order_qty(d.pop("min_order_qty"))
+
+        def _parse_order_multiple_qty(data: object) -> float | None:
+            if data is None:
+                return data
+            return cast(float | None, data)
+
+        order_multiple_qty = _parse_order_multiple_qty(d.pop("order_multiple_qty"))
+
+        def _parse_lead_time_days(data: object) -> int | None:
+            if data is None:
+                return data
+            return cast(int | None, data)
+
+        lead_time_days = _parse_lead_time_days(d.pop("lead_time_days"))
+
+        def _parse_unit_cost(data: object) -> float | None:
+            if data is None:
+                return data
+            return cast(float | None, data)
+
+        unit_cost = _parse_unit_cost(d.pop("unit_cost"))
+
+        def _parse_cost_currency(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        cost_currency = _parse_cost_currency(d.pop("cost_currency"))
+
+        def _parse_cost_list_id(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        cost_list_id = _parse_cost_list_id(d.pop("cost_list_id"))
+
+        def _parse_cost_rule_id(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        cost_rule_id = _parse_cost_rule_id(d.pop("cost_rule_id"))
+
+        is_primary = d.pop("is_primary")
+
+        is_active = d.pop("is_active")
+
+        def _parse_ext_data(data: object) -> ItemSourcingResponseExtDataType0 | None:
+            if data is None:
+                return data
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                ext_data_type_0 = ItemSourcingResponseExtDataType0.from_dict(data)
+
+                return ext_data_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(ItemSourcingResponseExtDataType0 | None, 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"))
+
+        item_sourcing_response = cls(
+            id=id,
+            project_id=project_id,
+            inventory_item_id=inventory_item_id,
+            item_sku=item_sku,
+            item_name=item_name,
+            vendor_id=vendor_id,
+            vendor_code=vendor_code,
+            vendor_name=vendor_name,
+            vendor_item_code=vendor_item_code,
+            origin_country_code=origin_country_code,
+            hts_code=hts_code,
+            uom_id=uom_id,
+            uom_code=uom_code,
+            uom_name=uom_name,
+            min_order_qty=min_order_qty,
+            order_multiple_qty=order_multiple_qty,
+            lead_time_days=lead_time_days,
+            unit_cost=unit_cost,
+            cost_currency=cost_currency,
+            cost_list_id=cost_list_id,
+            cost_rule_id=cost_rule_id,
+            is_primary=is_primary,
+            is_active=is_active,
+            ext_data=ext_data,
+            created_at=created_at,
+            updated_at=updated_at,
+        )
+
+        item_sourcing_response.additional_properties = d
+        return 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/item_sourcing_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="ItemSourcingResponseExtDataType0")
+
+
+@_attrs_define
+class ItemSourcingResponseExtDataType0:
+    """ """
+
+    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)
+        item_sourcing_response_ext_data_type_0 = cls()
+
+        item_sourcing_response_ext_data_type_0.additional_properties = d
+        return item_sourcing_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/item_sourcing_uom_option.py

@@ -0,0 +1,77 @@
+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="ItemSourcingUomOption")
+
+
+@_attrs_define
+class ItemSourcingUomOption:
+    """
+    Attributes:
+        id (str):
+        code (str):
+        name (str):
+    """
+
+    id: str
+    code: str
+    name: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        id = self.id
+
+        code = self.code
+
+        name = self.name
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "id": id,
+                "code": code,
+                "name": name,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        id = d.pop("id")
+
+        code = d.pop("code")
+
+        name = d.pop("name")
+
+        item_sourcing_uom_option = cls(
+            id=id,
+            code=code,
+            name=name,
+        )
+
+        item_sourcing_uom_option.additional_properties = d
+        return item_sourcing_uom_option
+
+    @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/item_sourcing_vendor_option.py

@@ -0,0 +1,77 @@
+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="ItemSourcingVendorOption")
+
+
+@_attrs_define
+class ItemSourcingVendorOption:
+    """
+    Attributes:
+        id (str):
+        code (str):
+        name (str):
+    """
+
+    id: str
+    code: str
+    name: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        id = self.id
+
+        code = self.code
+
+        name = self.name
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "id": id,
+                "code": code,
+                "name": name,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        id = d.pop("id")
+
+        code = d.pop("code")
+
+        name = d.pop("name")
+
+        item_sourcing_vendor_option = cls(
+            id=id,
+            code=code,
+            name=name,
+        )
+
+        item_sourcing_vendor_option.additional_properties = d
+        return item_sourcing_vendor_option
+
+    @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