stepxmlclient 1.0.0__py3-none-any.whl

stepxmlclient/model/organization.py

@@ -0,0 +1,167 @@
+"""Organization and dimensional models for STEP XML Client.
+
+Defines organizational and dimensional configuration classes including Contexts,
+Qualifiers, Dimensions, Tags, and Units used to organize and structure STEP MDM data.
+"""
+
+from typing import List, Optional, Any, Dict, TYPE_CHECKING
+from . import BaseObject
+
+if TYPE_CHECKING:
+    pass
+
+
+class Context(BaseObject):
+    """Context - multi-language/multi-dimensional context for data.
+    
+    Defines a context in which data can exist with language and dimensional variations.
+    Contexts enable organizing data by language, region, or dimensional axes.
+    
+    Supports:
+    - Multiple languages via Name elements
+    - Dimension point associations for multi-dimensional data
+    - Locale specification (language/region codes)
+    - Priority management for cross-context resolution
+    - Boolean state tracking (Selected, Referenced, Changed, Deleted)
+    
+    Attributes:
+        ID: Unique context identifier
+        Priority: Priority for context resolution
+        Locale: Language/locale code (e.g., 'en_US')
+        Name: Context name (localized)
+        DimensionPointLink: Links to dimension points
+        MetaData: Associated metadata
+        Selected: Whether context is selected
+        Referenced: Whether context is referenced
+        Changed: Whether context was changed
+        Deleted: Whether context is marked for deletion
+    """
+    _GROUP_NAME: str = 'contexts'
+    _TAG_NAME: str = 'Context'
+    _ATTRIBUTE_NAMES: List[str] = ["ID", "Priority", "Locale", "Selected", "Referenced", "Changed", "Deleted"]
+    _TEXT_NAMES: List[str] = ["Name"]
+    _CHILDREN_NAMES: List[str] = ["DimensionPointLink", "MetaData"]
+    
+    def __init__(self, data: Dict[str, Any]) -> None:
+        super().__init__(data)
+        # Initialize link lists if not provided
+        if "DimensionPointLink" not in self._data:
+            self._data["DimensionPointLink"] = []
+    
+    def add_dimension_point_link(self, dimension_id: str, dimension_point_id: str) -> None:
+        """Add a dimension point link to this context.
+        
+        Args:
+            dimension_id: ID of the dimension
+            dimension_point_id: ID of the dimension point
+        """
+        link_dict = {
+            "DimensionID": dimension_id,
+            "DimensionPointID": dimension_point_id
+        }
+        
+        if not isinstance(self._data["DimensionPointLink"], list):
+            self._data["DimensionPointLink"] = []
+        self._data["DimensionPointLink"].append(link_dict)
+
+
+class Qualifier(BaseObject):
+    """Qualifier - represents a dimension qualifier or multi-dimensional data point.
+    
+    Qualifiers enable multi-dimensional attribute management in STEP.
+    They combine dimension points to define a specific multi-dimensional position.
+    
+    Supports:
+    - Multiple dimension point associations
+    - Multi-language names
+    - Metadata tracking
+    """
+    _GROUP_NAME: str = 'qualifiers'
+    _TAG_NAME: str = 'Qualifier'
+    _ATTRIBUTE_NAMES: List[str] = ["ID"]
+    _TEXT_NAMES: List[str] = ["Name"]
+    _CHILDREN_NAMES: List[str] = ["DimensionPointLink", "MetaData"]
+    
+    def __init__(self, data: Dict[str, Any]) -> None:
+        super().__init__(data)
+        # Initialize link lists if not provided
+        if "DimensionPointLink" not in self._data:
+            self._data["DimensionPointLink"] = []
+    
+    def add_dimension_point_link(self, dimension_id: str, dimension_point_id: str) -> None:
+        """Add a dimension point link to this qualifier.
+        
+        Args:
+            dimension_id: ID of the dimension
+            dimension_point_id: ID of the dimension point
+        """
+        link_dict = {
+            "DimensionID": dimension_id,
+            "DimensionPointID": dimension_point_id
+        }
+        
+        if not isinstance(self._data["DimensionPointLink"], list):
+            self._data["DimensionPointLink"] = []
+        self._data["DimensionPointLink"].append(link_dict)
+
+
+class Dimension(BaseObject):
+    """Dimension - defines an axis for multi-dimensional data organization.
+    
+    Dimensions define categorization axes (e.g., Market, Color, Size) along which
+    products and attributes can be organized. Each dimension contains dimension points.
+    
+    Supports:
+    - Dimension points (values/positions along this axis)
+    - Multi-language names
+    - Duplicate point control
+    - Metadata tracking
+    """
+    _GROUP_NAME: str = 'dimensions'
+    _TAG_NAME: str = 'Dimension'
+    _ATTRIBUTE_NAMES: List[str] = ["ID", "AllowDuplicates"]
+    _TEXT_NAMES: List[str] = ["Name"]
+    _CHILDREN_NAMES: List[str] = ["DimensionPoint", "MetaData"]
+    
+    def __init__(self, data: Dict[str, Any]) -> None:
+        super().__init__(data)
+        # Initialize dimension points list if not provided
+        if "DimensionPoint" not in self._data:
+            self._data["DimensionPoint"] = []
+    
+    def add_dimension_point(self, dimension_point: Optional['DimensionPoint'] = None,
+                           **kwargs) -> None:
+        """Add a dimension point to this dimension.
+        
+        Can be called two ways:
+        1. With object: add_dimension_point(dimension_point=point_obj)
+        2. With parameters: add_dimension_point(ID="DP001", Name="Point Name")
+        """
+        if dimension_point is not None:
+            point = dimension_point
+        else:
+            point = DimensionPoint(kwargs)
+        
+        if not isinstance(self._data["DimensionPoint"], list):
+            self._data["DimensionPoint"] = []
+        self._data["DimensionPoint"].append(point)
+
+
+class DimensionPoint(BaseObject):
+    """DimensionPoint - represents a point/value within a dimension.
+    
+    Dimension points define the valid positions or values along a dimension axis.
+    For example, a "Color" dimension might have points: Red, Blue, Green.
+    
+    Supports:
+    - Multi-language names
+    - Metadata tracking
+    """
+    _GROUP_NAME: Optional[str] = None  # Used as child element only
+    _TAG_NAME: str = 'DimensionPoint'
+    _ATTRIBUTE_NAMES: List[str] = ["ID"]
+    _TEXT_NAMES: List[str] = ["Name"]
+    _CHILDREN_NAMES: List[str] = ["MetaData"]
+    
+    def __init__(self, data: Dict[str, Any]) -> None:
+        super().__init__(data)

stepxmlclient/model/product.py

@@ -0,0 +1,519 @@
+from typing import List, Optional, Any, Dict, TYPE_CHECKING
+from . import BaseObject
+
+if TYPE_CHECKING:
+    from .relations import (
+        AssetCrossReference,
+        ProductCrossReference,
+        ClassificationReference,
+        ClassificationCrossReference,
+        EntityCrossReference,
+    )
+    from .deletion import DeleteAssetCrossReference, DeleteProductCrossReference
+    from .complex_elements import (
+        STEPWorkflowStateBind,
+        SequenceProduct,
+        OverrideSubProduct,
+        PackagingReference,
+    )
+
+
+class Product(BaseObject):
+    """Product entity in STEP MDM.
+
+    This model serializes to STEP ``Product`` and supports both direct dictionary
+    payloads and helper methods.
+
+    Common top-level ``data`` keys:
+    - ``ID`` (str): Product identifier
+    - ``ParentId`` (str): Parent product ID
+    - ``UserTypeID`` (str): Product object type
+    - ``Name`` (str): Product name
+    - ``KeyValue`` (dict/list): external keys, e.g. ``{"KeyID": "ExternalKey", "value": "P-1"}``
+    - ``Values`` (dict): attribute value map
+
+    Frequently used child collections:
+    - ``AssetCrossReference``
+    - ``ProductCrossReference``
+    - ``ClassificationReference``
+    - ``ClassificationCrossReference``
+    - ``EntityCrossReference``
+
+    Usage examples:
+        Dict-first style::
+
+            product = Product({"ID": "P100", "UserTypeID": "UT_PRODUCT", "Name": "Bike"})
+            product.set_workflow_state_bind(workflow_id="WF_APPROVAL", state_id="STATE_DRAFT")
+            product.add_packaging_reference(product_id="BOX_01", quantity="1")
+
+        Pre-built object style::
+
+            from stepxmlclient.model import STEPWorkflowStateBind, SequenceProduct
+            product = Product({"ID": "P200", "UserTypeID": "UT_PRODUCT"})
+            product.set_workflow_state_bind(bind_object=STEPWorkflowStateBind({
+                "WorkflowID": "WF_APPROVAL", "StateID": "STATE_READY"
+            }))
+            product.add_sequence_product(sequence_object=SequenceProduct({"ID": "P201"}))
+    """
+
+    _GROUP_NAME: str = "products"
+    _TAG_NAME: str = "Product"
+    _ATTRIBUTE_NAMES: List[str] = [
+        "ID",
+        "ParentId",
+        "UserTypeID",
+        "QualifierID",
+        "Changed",
+        "Republished",
+        "Selected",
+        "Referenced",
+    ]
+    _TEXT_NAMES: List[str] = ["Name"]
+    _CHILDREN_NAMES: List[str] = [
+        "KeyValue",
+        "ParentKeyValue",
+        "STEPWorkflowStateBind",
+        "Values",
+        "DeleteSuppressedAssetCrossReference",
+        "SuppressedAssetCrossReference",
+        "AssetCrossReference",
+        "DeleteSuppressedProductCrossReference",
+        "SuppressedProductCrossReference",
+        "ProductCrossReference",
+        "DeleteSuppressedClassificationReference",
+        "DeleteClassificationReference",
+        "SuppressedClassificationReference",
+        "ClassificationReference",
+        "DeleteSuppressedClassificationCrossReference",
+        "DeleteClassificationCrossReference",
+        "SuppressedClassificationCrossReference",
+        "ClassificationCrossReference",
+        "DeleteSuppressedEntityCrossReference",
+        "DeleteEntityCrossReference",
+        "SuppressedEntityCrossReference",
+        "EntityCrossReference",
+        "DeleteAttributeLink",
+        "AttributeLink",
+        "DataContainerTypeLink",
+        "DeleteDataContainerTypeLink",
+        "DataContainers",
+        "DeleteAssetCrossReference",
+        "DeleteProductCrossReference",
+        "SequenceProduct",
+        "CurrentTasks",
+        "Terms",
+        "Tables",
+        "OverrideSubProduct",
+        "PackagingReference",
+    ]
+
+    def __init__(self, data: Dict[str, Any]) -> None:
+        super().__init__(data)
+        for rel_name in [
+            "DeleteSuppressedAssetCrossReference",
+            "SuppressedAssetCrossReference",
+            "AssetCrossReference",
+            "DeleteSuppressedProductCrossReference",
+            "SuppressedProductCrossReference",
+            "ProductCrossReference",
+            "DeleteSuppressedClassificationReference",
+            "DeleteClassificationReference",
+            "SuppressedClassificationReference",
+            "ClassificationReference",
+            "DeleteSuppressedClassificationCrossReference",
+            "DeleteClassificationCrossReference",
+            "SuppressedClassificationCrossReference",
+            "ClassificationCrossReference",
+            "DeleteSuppressedEntityCrossReference",
+            "DeleteEntityCrossReference",
+            "SuppressedEntityCrossReference",
+            "EntityCrossReference",
+            "DeleteAttributeLink",
+            "AttributeLink",
+            "DataContainerTypeLink",
+            "DeleteDataContainerTypeLink",
+            "DeleteAssetCrossReference",
+            "DeleteProductCrossReference",
+            "SequenceProduct",
+            "CurrentTasks",
+            "Terms",
+            "Tables",
+            "OverrideSubProduct",
+            "PackagingReference",
+        ]:
+            if rel_name not in self._data:
+                self._data[rel_name] = []
+
+    def add_asset_reference(
+        self,
+        asset_id: Optional[str] = None,
+        type_: Optional[str] = None,
+        qualifier_id: Optional[str] = None,
+        ref_object: Optional["AssetCrossReference"] = None,
+    ) -> None:
+        """Add an ``AssetCrossReference``.
+
+        Fields:
+        - ``AssetID``
+        - ``Type``
+        - ``QualifierID``
+        """
+        from .relations import AssetCrossReference
+
+        ref = ref_object or AssetCrossReference(
+            {"AssetID": asset_id, "Type": type_, "QualifierID": qualifier_id}
+        )
+        if not isinstance(self._data["AssetCrossReference"], list):
+            self._data["AssetCrossReference"] = []
+        self._data["AssetCrossReference"].append(ref)
+
+    def delete_asset_reference(
+        self,
+        asset_id: Optional[str] = None,
+        type_: Optional[str] = None,
+        qualifier_id: Optional[str] = None,
+        delete_ref_object: Optional["DeleteAssetCrossReference"] = None,
+    ) -> None:
+        """Add ``DeleteAssetCrossReference`` to remove an asset link.
+
+        Fields:
+        - ``AssetID``
+        - ``Type``
+        - ``QualifierID``
+        """
+        from .deletion import DeleteAssetCrossReference
+
+        delete_ref = delete_ref_object or DeleteAssetCrossReference(
+            {"AssetID": asset_id, "Type": type_, "QualifierID": qualifier_id}
+        )
+        if not isinstance(self._data["DeleteAssetCrossReference"], list):
+            self._data["DeleteAssetCrossReference"] = []
+        self._data["DeleteAssetCrossReference"].append(delete_ref)
+
+    def add_product_reference(
+        self,
+        product_id: Optional[str] = None,
+        type_: Optional[str] = None,
+        qualifier_id: Optional[str] = None,
+        mount_location: Optional[str] = None,
+        ref_object: Optional["ProductCrossReference"] = None,
+    ) -> None:
+        """Add a ``ProductCrossReference``.
+
+        Fields:
+        - ``ProductID``
+        - ``Type``
+        - ``QualifierID``
+        - ``MountLocation``
+        """
+        from .relations import ProductCrossReference
+
+        ref = ref_object or ProductCrossReference(
+            {
+                "ProductID": product_id,
+                "Type": type_,
+                "QualifierID": qualifier_id,
+                "MountLocation": mount_location,
+            }
+        )
+        if not isinstance(self._data["ProductCrossReference"], list):
+            self._data["ProductCrossReference"] = []
+        self._data["ProductCrossReference"].append(ref)
+
+    def delete_product_reference(
+        self,
+        product_id: Optional[str] = None,
+        type_: Optional[str] = None,
+        qualifier_id: Optional[str] = None,
+        mount_location: Optional[str] = None,
+        delete_ref_object: Optional["DeleteProductCrossReference"] = None,
+    ) -> None:
+        """Add ``DeleteProductCrossReference`` to remove a product link.
+
+        Fields:
+        - ``ProductID``
+        - ``Type``
+        - ``QualifierID``
+        - ``MountLocation``
+        """
+        from .deletion import DeleteProductCrossReference
+
+        delete_ref = delete_ref_object or DeleteProductCrossReference(
+            {
+                "ProductID": product_id,
+                "Type": type_,
+                "QualifierID": qualifier_id,
+                "MountLocation": mount_location,
+            }
+        )
+        if not isinstance(self._data["DeleteProductCrossReference"], list):
+            self._data["DeleteProductCrossReference"] = []
+        self._data["DeleteProductCrossReference"].append(delete_ref)
+
+    def add_classification_reference(
+        self,
+        classification_id: Optional[str] = None,
+        type_: Optional[str] = None,
+        qualifier_id: Optional[str] = None,
+        mount_location: Optional[str] = None,
+        ref_object: Optional["ClassificationReference"] = None,
+    ) -> None:
+        """Add ``ClassificationReference`` (not CrossReference).
+
+        Fields:
+        - ``ClassificationID``
+        - ``Type``
+        - ``QualifierID``
+        - ``MountLocation``
+        """
+        from .relations import ClassificationReference, ClassificationCrossReference
+
+        if ref_object is not None:
+            ref = ref_object
+            if isinstance(ref, ClassificationCrossReference):
+                ref = ClassificationReference(dict(ref._data))
+        else:
+            ref = ClassificationReference(
+                {
+                    "ClassificationID": classification_id,
+                    "Type": type_,
+                    "QualifierID": qualifier_id,
+                    "MountLocation": mount_location,
+                }
+            )
+
+        if not isinstance(self._data["ClassificationReference"], list):
+            self._data["ClassificationReference"] = []
+        self._data["ClassificationReference"].append(ref)
+
+    def add_classification_cross_reference(
+        self,
+        classification_id: Optional[str] = None,
+        type_: Optional[str] = None,
+        qualifier_id: Optional[str] = None,
+        mount_location: Optional[str] = None,
+        ref_object: Optional["ClassificationCrossReference"] = None,
+    ) -> None:
+        """Add explicit ``ClassificationCrossReference``.
+
+        Fields:
+        - ``ClassificationID``
+        - ``Type``
+        - ``QualifierID``
+        - ``MountLocation``
+        """
+        from .relations import ClassificationCrossReference
+
+        ref = ref_object or ClassificationCrossReference(
+            {
+                "ClassificationID": classification_id,
+                "Type": type_,
+                "QualifierID": qualifier_id,
+                "MountLocation": mount_location,
+            }
+        )
+        if not isinstance(self._data["ClassificationCrossReference"], list):
+            self._data["ClassificationCrossReference"] = []
+        self._data["ClassificationCrossReference"].append(ref)
+
+    def add_entity_reference(
+        self,
+        entity_id: Optional[str] = None,
+        type_: Optional[str] = None,
+        qualifier_id: Optional[str] = None,
+        mount_location: Optional[str] = None,
+        ref_object: Optional["EntityCrossReference"] = None,
+    ) -> None:
+        """Add ``EntityCrossReference``.
+
+        Fields:
+        - ``EntityID``
+        - ``Type``
+        - ``QualifierID``
+        - ``MountLocation``
+        """
+        from .relations import EntityCrossReference
+
+        ref = ref_object or EntityCrossReference(
+            {
+                "EntityID": entity_id,
+                "Type": type_,
+                "QualifierID": qualifier_id,
+                "MountLocation": mount_location,
+            }
+        )
+        if not isinstance(self._data["EntityCrossReference"], list):
+            self._data["EntityCrossReference"] = []
+        self._data["EntityCrossReference"].append(ref)
+
+    def set_workflow_state_bind(
+        self,
+        workflow_id: Optional[str] = None,
+        state_id: Optional[str] = None,
+        bind_data: Optional[Dict[str, Any]] = None,
+        bind_object: Optional["STEPWorkflowStateBind"] = None,
+    ) -> None:
+        """Set ``STEPWorkflowStateBind``.
+
+        Required XSD keys:
+        - ``WorkflowID``
+        - ``StateID``
+
+        Compatibility:
+        - legacy dict keys ``ID`` and ``CurrentStateID`` are normalized.
+        """
+        if bind_object is not None:
+            self._data["STEPWorkflowStateBind"] = bind_object
+            return
+
+        if bind_data is not None:
+            normalized = dict(bind_data)
+            if "WorkflowID" not in normalized and "ID" in normalized:
+                normalized["WorkflowID"] = normalized.pop("ID")
+            if "StateID" not in normalized and "CurrentStateID" in normalized:
+                normalized["StateID"] = normalized.pop("CurrentStateID")
+            self._data["STEPWorkflowStateBind"] = normalized
+            return
+
+        self._data["STEPWorkflowStateBind"] = {
+            "WorkflowID": workflow_id,
+            "StateID": state_id,
+        }
+
+    def add_sequence_product(
+        self,
+        product_id: Optional[str] = None,
+        changed: Optional[bool] = None,
+        key_values: Optional[List[Dict[str, Any]]] = None,
+        sequence_data: Optional[Dict[str, Any]] = None,
+        sequence_object: Optional["SequenceProduct"] = None,
+    ) -> None:
+        """Add ``SequenceProduct``.
+
+        XSD fields:
+        - ``ID`` (required)
+        - ``Changed`` (optional)
+        - ``KeyValue`` (optional, list)
+        """
+        if sequence_object is not None:
+            entry: Any = sequence_object
+        elif sequence_data is not None:
+            entry = sequence_data
+        else:
+            entry = {"ID": product_id, "Changed": changed, "KeyValue": key_values}
+
+        if not isinstance(self._data.get("SequenceProduct"), list):
+            self._data["SequenceProduct"] = []
+        self._data["SequenceProduct"].append(entry)
+
+    def add_current_task(self, task_data: Optional[Dict[str, Any]] = None) -> None:
+        """Add ``CurrentTasks``/``Task`` data.
+
+        Typical task keys:
+        - ``STEPWorkflowID``
+        - ``StateID``
+        - ``AssigneeID``
+        - ``AssignedToGroup``
+        - ``EntryTime``
+        - optional: ``Deadline``, ``Priority``, ``StatusID``
+        """
+        if not isinstance(self._data.get("CurrentTasks"), list):
+            self._data["CurrentTasks"] = []
+        self._data["CurrentTasks"].append(task_data or {})
+
+    def add_term(self, term_data: Optional[Dict[str, Any]] = None) -> None:
+        """Add ``Terms``/``Term`` data.
+
+        Common term keys:
+        - ``TermsListID``
+        - ``MinimumQuantity`` / ``MaximumQuantity``
+        - ``StartDate`` / ``EndDate``
+        - ``LeadTime``
+        - ``UnitID``
+        - ``LotSize``
+        - optional text value: ``value``
+        """
+        if not isinstance(self._data.get("Terms"), list):
+            self._data["Terms"] = []
+        self._data["Terms"].append(term_data or {})
+
+    def add_table(self, table_data: Optional[Dict[str, Any]] = None) -> None:
+        """Add ``Tables`` data.
+
+        Supported container forms:
+        - ``{"Table": {...}}``
+        - ``{"TableDefinition": {...}}``
+
+        Common ``Table`` attributes:
+        - ``ID``
+        - ``ContextID``
+        - ``TableTypeID``
+        """
+        if not isinstance(self._data.get("Tables"), list):
+            self._data["Tables"] = []
+        self._data["Tables"].append(table_data or {})
+
+    def add_override_sub_product(
+        self,
+        product_id: Optional[str] = None,
+        analyzer_result: Optional[str] = None,
+        override_data: Optional[Dict[str, Any]] = None,
+        override_object: Optional["OverrideSubProduct"] = None,
+    ) -> None:
+        """Add ``OverrideSubProduct``.
+
+        XSD fields:
+        - ``ProductID`` (required)
+        - ``AnalyzerResult`` (optional, deprecated)
+        """
+        if override_object is not None:
+            entry: Any = override_object
+        elif override_data is not None:
+            entry = override_data
+        else:
+            entry = {"ProductID": product_id, "AnalyzerResult": analyzer_result}
+
+        if not isinstance(self._data.get("OverrideSubProduct"), list):
+            self._data["OverrideSubProduct"] = []
+        self._data["OverrideSubProduct"].append(entry)
+
+    def add_packaging_reference(
+        self,
+        product_id: Optional[str] = None,
+        quantity: Optional[str] = None,
+        packaging_data: Optional[Dict[str, Any]] = None,
+        packaging_object: Optional["PackagingReference"] = None,
+    ) -> None:
+        """Add ``PackagingReference``.
+
+        Required XSD fields:
+        - ``ProductID``
+        - ``Quantity``
+        """
+        if packaging_object is not None:
+            entry: Any = packaging_object
+        elif packaging_data is not None:
+            entry = packaging_data
+        else:
+            entry = {"ProductID": product_id, "Quantity": quantity}
+
+        if not isinstance(self._data.get("PackagingReference"), list):
+            self._data["PackagingReference"] = []
+        self._data["PackagingReference"].append(entry)
+
+
+class ProductReplacementRule(BaseObject):
+    _GROUP_NAME: str = "product_replacement_rules"
+    _TAG_NAME: str = "Product"
+    _ATTRIBUTE_NAMES: List[str] = [
+        "ID",
+        "ParentId",
+        "UserTypeID",
+        "QualifierID",
+        "Changed",
+        "Republished",
+        "Selected",
+        "Referenced",
+    ]
+    _TEXT_NAMES: List[str] = ["Name"]
+    _CHILDREN_NAMES: List[str] = ["KeyValue", "ParentKeyValue", "Values"]