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

convexity_api_client/models/erp_project_config.py

@@ -10,6 +10,7 @@ from ..types import UNSET, Unset
 if TYPE_CHECKING:
     from ..models.erp_forecasting_config import ErpForecastingConfig
     from ..models.erp_inventory_policy_writeback_action_config import ErpInventoryPolicyWritebackActionConfig
+    from ..models.erp_project_config_tablecolumns import ErpProjectConfigTablecolumns
     from ..models.erp_purchase_order_line_detail_panel_config import ErpPurchaseOrderLineDetailPanelConfig
     from ..models.erp_purchase_order_writeback_action_config import ErpPurchaseOrderWritebackActionConfig
     from ..models.erp_sales_order_builder_surface_config import ErpSalesOrderBuilderSurfaceConfig
@@ -27,6 +28,7 @@ class ErpProjectConfig:
         type_ (Literal['erp_project_config'] | Unset):  Default: 'erp_project_config'.
         source_of_record (ErpSourceOfRecordConfig | Unset):
         forecasting (ErpForecastingConfig | Unset):
+        table_columns (ErpProjectConfigTablecolumns | Unset):
         show_kpi_cards (bool | Unset):  Default: False.
         inventory_item_browser (ErpSurfaceConfig | Unset):
         inventory_replenishment_policy_list (ErpSurfaceConfig | Unset):
@@ -57,6 +59,7 @@ class ErpProjectConfig:
     type_: Literal["erp_project_config"] | Unset = "erp_project_config"
     source_of_record: ErpSourceOfRecordConfig | Unset = UNSET
     forecasting: ErpForecastingConfig | Unset = UNSET
+    table_columns: ErpProjectConfigTablecolumns | Unset = UNSET
     show_kpi_cards: bool | Unset = False
     inventory_item_browser: ErpSurfaceConfig | Unset = UNSET
     inventory_replenishment_policy_list: ErpSurfaceConfig | Unset = UNSET
@@ -89,6 +92,10 @@ class ErpProjectConfig:
         if not isinstance(self.forecasting, Unset):
             forecasting = self.forecasting.to_dict()
 
+        table_columns: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.table_columns, Unset):
+            table_columns = self.table_columns.to_dict()
+
         show_kpi_cards = self.show_kpi_cards
 
         inventory_item_browser: dict[str, Any] | Unset = UNSET
@@ -176,6 +183,8 @@ class ErpProjectConfig:
             field_dict["source_of_record"] = source_of_record
         if forecasting is not UNSET:
             field_dict["forecasting"] = forecasting
+        if table_columns is not UNSET:
+            field_dict["tableColumns"] = table_columns
         if show_kpi_cards is not UNSET:
             field_dict["show_kpi_cards"] = show_kpi_cards
         if inventory_item_browser is not UNSET:
@@ -223,6 +232,7 @@ class ErpProjectConfig:
     def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
         from ..models.erp_forecasting_config import ErpForecastingConfig
         from ..models.erp_inventory_policy_writeback_action_config import ErpInventoryPolicyWritebackActionConfig
+        from ..models.erp_project_config_tablecolumns import ErpProjectConfigTablecolumns
         from ..models.erp_purchase_order_line_detail_panel_config import ErpPurchaseOrderLineDetailPanelConfig
         from ..models.erp_purchase_order_writeback_action_config import ErpPurchaseOrderWritebackActionConfig
         from ..models.erp_sales_order_builder_surface_config import ErpSalesOrderBuilderSurfaceConfig
@@ -248,6 +258,13 @@ class ErpProjectConfig:
         else:
             forecasting = ErpForecastingConfig.from_dict(_forecasting)
 
+        _table_columns = d.pop("tableColumns", UNSET)
+        table_columns: ErpProjectConfigTablecolumns | Unset
+        if isinstance(_table_columns, Unset):
+            table_columns = UNSET
+        else:
+            table_columns = ErpProjectConfigTablecolumns.from_dict(_table_columns)
+
         show_kpi_cards = d.pop("show_kpi_cards", UNSET)
 
         _inventory_item_browser = d.pop("inventory_item_browser", UNSET)
@@ -391,6 +408,7 @@ class ErpProjectConfig:
             type_=type_,
             source_of_record=source_of_record,
             forecasting=forecasting,
+            table_columns=table_columns,
             show_kpi_cards=show_kpi_cards,
             inventory_item_browser=inventory_item_browser,
             inventory_replenishment_policy_list=inventory_replenishment_policy_list,

convexity_api_client/models/erp_project_config_tablecolumns.py

@@ -0,0 +1,68 @@
+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.erp_configured_column_config import ErpConfiguredColumnConfig
+
+
+T = TypeVar("T", bound="ErpProjectConfigTablecolumns")
+
+
+@_attrs_define
+class ErpProjectConfigTablecolumns:
+    """ """
+
+    additional_properties: dict[str, list[ErpConfiguredColumnConfig]] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+
+        field_dict: dict[str, Any] = {}
+        for prop_name, prop in self.additional_properties.items():
+            field_dict[prop_name] = []
+            for additional_property_item_data in prop:
+                additional_property_item = additional_property_item_data.to_dict()
+                field_dict[prop_name].append(additional_property_item)
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.erp_configured_column_config import ErpConfiguredColumnConfig
+
+        d = dict(src_dict)
+        erp_project_config_tablecolumns = cls()
+
+        additional_properties = {}
+        for prop_name, prop_dict in d.items():
+            additional_property = []
+            _additional_property = prop_dict
+            for additional_property_item_data in _additional_property:
+                additional_property_item = ErpConfiguredColumnConfig.from_dict(additional_property_item_data)
+
+                additional_property.append(additional_property_item)
+
+            additional_properties[prop_name] = additional_property
+
+        erp_project_config_tablecolumns.additional_properties = additional_properties
+        return erp_project_config_tablecolumns
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> list[ErpConfiguredColumnConfig]:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: list[ErpConfiguredColumnConfig]) -> 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/erp_user_table_preference.py

@@ -0,0 +1,201 @@
+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
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.profile import Profile
+    from ..models.project import Project
+
+
+T = TypeVar("T", bound="ERPUserTablePreference")
+
+
+@_attrs_define
+class ERPUserTablePreference:
+    """Per-user presentation preferences for one ERP table surface.
+
+
+    Attributes:
+        id (str):
+        project_id (str):
+        user_id (str):
+        surface_key (str):
+        visible_column_ids (list[str]):
+        column_widths (str):
+        column_labels (str):
+        created_at (datetime.datetime):
+        updated_at (datetime.datetime):
+        project (None | Project | Unset):
+        profile (None | Profile | Unset):
+    """
+
+    id: str
+    project_id: str
+    user_id: str
+    surface_key: str
+    visible_column_ids: list[str]
+    column_widths: str
+    column_labels: str
+    created_at: datetime.datetime
+    updated_at: datetime.datetime
+    project: None | Project | Unset = UNSET
+    profile: None | Profile | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.profile import Profile
+        from ..models.project import Project
+
+        id = self.id
+
+        project_id = self.project_id
+
+        user_id = self.user_id
+
+        surface_key = self.surface_key
+
+        visible_column_ids = self.visible_column_ids
+
+        column_widths = self.column_widths
+
+        column_labels = self.column_labels
+
+        created_at = self.created_at.isoformat()
+
+        updated_at = self.updated_at.isoformat()
+
+        project: dict[str, Any] | None | Unset
+        if isinstance(self.project, Unset):
+            project = UNSET
+        elif isinstance(self.project, Project):
+            project = self.project.to_dict()
+        else:
+            project = self.project
+
+        profile: dict[str, Any] | None | Unset
+        if isinstance(self.profile, Unset):
+            profile = UNSET
+        elif isinstance(self.profile, Profile):
+            profile = self.profile.to_dict()
+        else:
+            profile = self.profile
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "id": id,
+                "project_id": project_id,
+                "user_id": user_id,
+                "surface_key": surface_key,
+                "visible_column_ids": visible_column_ids,
+                "column_widths": column_widths,
+                "column_labels": column_labels,
+                "created_at": created_at,
+                "updated_at": updated_at,
+            }
+        )
+        if project is not UNSET:
+            field_dict["project"] = project
+        if profile is not UNSET:
+            field_dict["profile"] = profile
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.profile import Profile
+        from ..models.project import Project
+
+        d = dict(src_dict)
+        id = d.pop("id")
+
+        project_id = d.pop("project_id")
+
+        user_id = d.pop("user_id")
+
+        surface_key = d.pop("surface_key")
+
+        visible_column_ids = cast(list[str], d.pop("visible_column_ids"))
+
+        column_widths = d.pop("column_widths")
+
+        column_labels = d.pop("column_labels")
+
+        created_at = datetime.datetime.fromisoformat(d.pop("created_at"))
+
+        updated_at = datetime.datetime.fromisoformat(d.pop("updated_at"))
+
+        def _parse_project(data: object) -> None | Project | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                project_type_0 = Project.from_dict(data)
+
+                return project_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(None | Project | Unset, data)
+
+        project = _parse_project(d.pop("project", UNSET))
+
+        def _parse_profile(data: object) -> None | Profile | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                profile_type_0 = Profile.from_dict(data)
+
+                return profile_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(None | Profile | Unset, data)
+
+        profile = _parse_profile(d.pop("profile", UNSET))
+
+        erp_user_table_preference = cls(
+            id=id,
+            project_id=project_id,
+            user_id=user_id,
+            surface_key=surface_key,
+            visible_column_ids=visible_column_ids,
+            column_widths=column_widths,
+            column_labels=column_labels,
+            created_at=created_at,
+            updated_at=updated_at,
+            project=project,
+            profile=profile,
+        )
+
+        erp_user_table_preference.additional_properties = d
+        return erp_user_table_preference
+
+    @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/erp_user_table_preference_response.py

@@ -0,0 +1,102 @@
+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.erp_user_table_preference_response_columnlabels import ERPUserTablePreferenceResponseColumnlabels
+    from ..models.erp_user_table_preference_response_columnwidths import ERPUserTablePreferenceResponseColumnwidths
+
+
+T = TypeVar("T", bound="ERPUserTablePreferenceResponse")
+
+
+@_attrs_define
+class ERPUserTablePreferenceResponse:
+    """
+    Attributes:
+        surface_key (str):
+        visible_column_ids (list[str]):
+        column_widths (ERPUserTablePreferenceResponseColumnwidths):
+        column_labels (ERPUserTablePreferenceResponseColumnlabels):
+        updated_at (datetime.datetime):
+    """
+
+    surface_key: str
+    visible_column_ids: list[str]
+    column_widths: ERPUserTablePreferenceResponseColumnwidths
+    column_labels: ERPUserTablePreferenceResponseColumnlabels
+    updated_at: datetime.datetime
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        surface_key = self.surface_key
+
+        visible_column_ids = self.visible_column_ids
+
+        column_widths = self.column_widths.to_dict()
+
+        column_labels = self.column_labels.to_dict()
+
+        updated_at = self.updated_at.isoformat()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "surfaceKey": surface_key,
+                "visibleColumnIds": visible_column_ids,
+                "columnWidths": column_widths,
+                "columnLabels": column_labels,
+                "updatedAt": updated_at,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.erp_user_table_preference_response_columnlabels import ERPUserTablePreferenceResponseColumnlabels
+        from ..models.erp_user_table_preference_response_columnwidths import ERPUserTablePreferenceResponseColumnwidths
+
+        d = dict(src_dict)
+        surface_key = d.pop("surfaceKey")
+
+        visible_column_ids = cast(list[str], d.pop("visibleColumnIds"))
+
+        column_widths = ERPUserTablePreferenceResponseColumnwidths.from_dict(d.pop("columnWidths"))
+
+        column_labels = ERPUserTablePreferenceResponseColumnlabels.from_dict(d.pop("columnLabels"))
+
+        updated_at = datetime.datetime.fromisoformat(d.pop("updatedAt"))
+
+        erp_user_table_preference_response = cls(
+            surface_key=surface_key,
+            visible_column_ids=visible_column_ids,
+            column_widths=column_widths,
+            column_labels=column_labels,
+            updated_at=updated_at,
+        )
+
+        erp_user_table_preference_response.additional_properties = d
+        return erp_user_table_preference_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/erp_user_table_preference_response_columnlabels.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="ERPUserTablePreferenceResponseColumnlabels")
+
+
+@_attrs_define
+class ERPUserTablePreferenceResponseColumnlabels:
+    """ """
+
+    additional_properties: dict[str, str] = _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)
+        erp_user_table_preference_response_columnlabels = cls()
+
+        erp_user_table_preference_response_columnlabels.additional_properties = d
+        return erp_user_table_preference_response_columnlabels
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> str:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: str) -> 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/erp_user_table_preference_response_columnwidths.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="ERPUserTablePreferenceResponseColumnwidths")
+
+
+@_attrs_define
+class ERPUserTablePreferenceResponseColumnwidths:
+    """ """
+
+    additional_properties: dict[str, int] = _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)
+        erp_user_table_preference_response_columnwidths = cls()
+
+        erp_user_table_preference_response_columnwidths.additional_properties = d
+        return erp_user_table_preference_response_columnwidths
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> int:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: int) -> 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/import_task_payload.py

@@ -0,0 +1,108 @@
+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 ..models.import_task_payload_type import ImportTaskPayloadType
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="ImportTaskPayload")
+
+
+@_attrs_define
+class ImportTaskPayload:
+    """Payload for IMPORT_VALIDATE / IMPORT_COMMIT worker tasks.
+
+    Carries only the import job id (+ project + initiating user). The per-entity
+    strategy is resolved from ``ImportJob.entity_type`` at execution time, so
+    this payload stays entity-agnostic.
+
+    A single model serves both import task types; ``type`` acts as the
+    discriminator so the payload can participate in ``WorkerTaskPayload``.
+
+        Attributes:
+            type_ (ImportTaskPayloadType): Which import stage this payload drives (validate or commit)
+            import_id (str):
+            project_id (str):
+            user_id (None | str | Unset):
+    """
+
+    type_: ImportTaskPayloadType
+    import_id: str
+    project_id: str
+    user_id: None | str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        type_ = self.type_.value
+
+        import_id = self.import_id
+
+        project_id = self.project_id
+
+        user_id: None | str | Unset
+        if isinstance(self.user_id, Unset):
+            user_id = UNSET
+        else:
+            user_id = self.user_id
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "type": type_,
+                "importId": import_id,
+                "projectId": project_id,
+            }
+        )
+        if user_id is not UNSET:
+            field_dict["userId"] = user_id
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        type_ = ImportTaskPayloadType(d.pop("type"))
+
+        import_id = d.pop("importId")
+
+        project_id = d.pop("projectId")
+
+        def _parse_user_id(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        user_id = _parse_user_id(d.pop("userId", UNSET))
+
+        import_task_payload = cls(
+            type_=type_,
+            import_id=import_id,
+            project_id=project_id,
+            user_id=user_id,
+        )
+
+        import_task_payload.additional_properties = d
+        return import_task_payload
+
+    @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/import_task_payload_type.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class ImportTaskPayloadType(str, Enum):
+    IMPORT_COMMIT = "import_commit"
+    IMPORT_VALIDATE = "import_validate"
+
+    def __str__(self) -> str:
+        return str(self.value)