stepxmlclient 1.0.0__py3-none-any.whl

stepxmlclient/model/attribute.py

@@ -0,0 +1,288 @@
+"""Attribute model for STEP XML Client.
+
+Defines the Attribute entity class for representing attribute definitions in STEP MDM.
+Attributes define the properties that can be assigned to products, assets, and entities.
+"""
+
+from typing import List, Optional, Any, Dict, TYPE_CHECKING
+from . import BaseObject
+
+if TYPE_CHECKING:
+    pass
+
+
+class Attribute(BaseObject):
+    """Attribute definition in STEP MDM.
+    
+    Defines a property/characteristic that can be assigned to products, assets, and entities.
+    Supports multiple data types, validation rules, units, and dimensional analysis.
+    
+    Attributes:
+        ID: Unique attribute identifier
+        DefaultUnitID: Default unit for numeric values
+        ProductMode: 'Normal' or 'Property' (property attributes have limited usage)
+        CryptographicKeyID: Optional encryption key for sensitive data
+        HierarchicalFiltering: Whether to use hierarchical filtering
+        ClassificationHierarchicalFiltering: Whether to use classification hierarchy filtering
+        ExternallyMaintained: Whether values are maintained externally
+        FullTextIndexed: Whether to index for full-text search
+        MultiValued: Whether attribute can have multiple values
+        Mandatory: Whether attribute is required
+        Derived: Whether value is computed/derived
+        Selected: Whether attribute is selected in UI
+        Referenced: Whether attribute is referenced elsewhere
+        Changed: Whether attribute was modified
+        Deleted: Whether attribute is marked for deletion
+        Name: Attribute name (localized)
+        Validation: Data type validation configuration
+        ListOfValueLink: Link to List-of-Values for choice attributes
+        ValueTemplate: Template for attribute values
+        UnitTemplate: Template for units
+        DimensionLink: Links to dimensional definitions
+        MetaData: Metadata associated with attribute
+        AttributeGroupLink: Links to attribute groups
+        UserTypeLink: Links to user types
+        LinkType: Link type associations
+        ValueFilter: Filters for attribute values
+        CurrentTasks: Current task information
+    """
+    _GROUP_NAME: str = 'attributes'
+    _TAG_NAME: str = 'Attribute'
+    _ATTRIBUTE_NAMES: List[str] = [
+        "ID", "DefaultUnitID", "ProductMode", "CryptographicKeyID",
+        "HierarchicalFiltering", "ClassificationHierarchicalFiltering",
+        "ExternallyMaintained", "FullTextIndexed", "MultiValued",
+        "Mandatory", "Derived", "Selected", "Referenced", "Changed", "Deleted"
+    ]
+    _TEXT_NAMES: List[str] = ["Name"]
+    _CHILDREN_NAMES: List[str] = [
+        "Validation",
+        "ListOfValueLink",
+        "ValueTemplate",
+        "UnitTemplate",
+        "DimensionLink",
+        "MetaData",
+        "AttributeGroupLink",
+        "UserTypeLink",
+        "LinkType",
+        "ValueFilter",
+        "CurrentTasks"
+    ]
+    
+    def __init__(self, data: Dict[str, Any]) -> None:
+        super().__init__(data)
+        # Initialize link lists if not provided
+        for link_name in ["DimensionLink", "AttributeGroupLink", "UserTypeLink", "LinkType"]:
+            if link_name not in self._data:
+                self._data[link_name] = []
+
+
+class AttributeGroup(BaseObject):
+    """AttributeGroup - hierarchical grouping of attributes for organizational purposes.
+    
+    Supports:
+    - Nested attribute groups (parent/child hierarchy)
+    - Workbench visibility settings
+    - Manual sorting control
+    - Profiling exclusion options
+    - Configuration/view definitions
+    - Boolean state tracking (ShowInWorkbench, ExcludeFromProfiling, Selected, Referenced, etc.)
+    """
+    _GROUP_NAME: str = 'attributegroups'
+    _TAG_NAME: str = 'AttributeGroup'
+    _ATTRIBUTE_NAMES: List[str] = [
+        "ID", "ParentID", "ShowInWorkbench", "ExcludeFromProfiling",
+        "Referenced", "ManuallySorted", "Selected", "Changed", "Deleted"
+    ]
+    _TEXT_NAMES: List[str] = ["Name"]
+    _CHILDREN_NAMES: List[str] = [
+        "MetaData",
+        "Configuration",
+        "AttributeSequence",
+        "AttributeGroup"  # Nested attribute groups
+    ]
+    
+    def __init__(self, data: Dict[str, Any]) -> None:
+        super().__init__(data)
+        # Initialize nested attribute groups list
+        if "AttributeGroup" not in self._data:
+            self._data["AttributeGroup"] = []
+    
+    def add_nested_attribute_group(self, attribute_group: Optional['AttributeGroup'] = None,
+                                  **kwargs) -> None:
+        """Add nested child attribute group.
+        
+        Can be called two ways:
+        1. With object: add_nested_attribute_group(attribute_group=child_group)
+        2. With parameters: add_nested_attribute_group(ID="AG002", Name="Child Group")
+        """
+        if attribute_group is not None:
+            nested = attribute_group
+        else:
+            nested = AttributeGroup(kwargs)
+        
+        if not isinstance(self._data["AttributeGroup"], list):
+            self._data["AttributeGroup"] = []
+        self._data["AttributeGroup"].append(nested)
+
+
+class ListOfValues(BaseObject):
+    """ListOfValues - defines a set of allowed values for an attribute with optional grouping.
+    
+    Supports:
+    - Hierarchical value groups (parent/child)
+    - Value definitions and deletion
+    - User-contributed values
+    - Value ID usage control
+    - Validation rules
+    - Dimensional analysis (DimensionLink)
+    - Unit definitions (DefaultUnitID)
+    - Boolean state tracking (AllowUserValueAddition, UseValueID, ReplaceListOfValuesValues, etc.)
+    """
+    _GROUP_NAME: str = 'listofvalues'
+    _TAG_NAME: str = 'ListOfValues'
+    _ATTRIBUTE_NAMES: List[str] = [
+        "ID", "ParentID", "AllowUserValueAddition", "UseValueID",
+        "IDPattern", "ReplaceListOfValuesValues", "DefaultUnitID"
+    ]
+    _TEXT_NAMES: List[str] = ["Name"]
+    _CHILDREN_NAMES: List[str] = [
+        "Validation",
+        "DimensionLink",
+        "MetaData",
+        "AttributeGroupLink",
+        "Value",
+        "ValueGroup",
+        "DeleteValue",
+        "ListOfValuesGroup"  # Nested groups
+    ]
+    
+    def __init__(self, data: Dict[str, Any]) -> None:
+        super().__init__(data)
+        # Initialize link lists if not provided
+        for link_name in ["DimensionLink", "AttributeGroupLink"]:
+            if link_name not in self._data:
+                self._data[link_name] = []
+        
+        # Initialize value lists
+        for value_name in ["Value", "ValueGroup", "DeleteValue", "ListOfValuesGroup"]:
+            if value_name not in self._data:
+                self._data[value_name] = []
+    
+    def add_value(self, value_id: Optional[str] = None,
+                 name: Optional[str] = None,
+                 **kwargs) -> None:
+        """Add a value to this list of values.
+        
+        Args:
+            value_id: ID of the value (if UseValueID=true)
+            name: Display name of the value
+            **kwargs: Additional attributes to pass to Value element
+        """
+        value_dict = {}
+        if value_id is not None:
+            value_dict["ID"] = value_id
+        if name is not None:
+            value_dict["Name"] = name
+        value_dict.update(kwargs)
+        
+        if not isinstance(self._data["Value"], list):
+            self._data["Value"] = []
+        self._data["Value"].append(value_dict)
+    
+    def delete_value(self, value_id: str) -> None:
+        """Mark a value for deletion from this list of values.
+        
+        Args:
+            value_id: ID of the value to delete
+        """
+        delete_dict = {"ID": value_id}
+        
+        if not isinstance(self._data["DeleteValue"], list):
+            self._data["DeleteValue"] = []
+        self._data["DeleteValue"].append(delete_dict)
+    
+    def add_value_group(self, value_group: Optional['ValueGroup'] = None,
+                       **kwargs) -> None:
+        """Add a value group (for grouped value organization).
+        
+        Can be called two ways:
+        1. With object: add_value_group(value_group=group_obj)
+        2. With parameters: add_value_group(ID="VG001", Name="Group Name")
+        """
+        if value_group is not None:
+            group = value_group
+        else:
+            group = ValueGroup(kwargs)
+        
+        if not isinstance(self._data["ValueGroup"], list):
+            self._data["ValueGroup"] = []
+        self._data["ValueGroup"].append(group)
+    
+    def add_nested_list_of_values_group(self, group: Optional['ListOfValuesGroup'] = None,
+                                       **kwargs) -> None:
+        """Add nested list of values group for hierarchical organization.
+        
+        Can be called two ways:
+        1. With object: add_nested_list_of_values_group(group=child_group)
+        2. With parameters: add_nested_list_of_values_group(ID="LOG001", Name="Group")
+        """
+        if group is not None:
+            nested = group
+        else:
+            nested = ListOfValuesGroup(kwargs)
+        
+        if not isinstance(self._data["ListOfValuesGroup"], list):
+            self._data["ListOfValuesGroup"] = []
+        self._data["ListOfValuesGroup"].append(nested)
+
+
+class ValueGroup(BaseObject):
+    """ValueGroup - groups related values within a ListOfValues for organizational purposes."""
+    _GROUP_NAME: Optional[str] = None  # Used as child element only
+    _TAG_NAME: str = 'ValueGroup'
+    _ATTRIBUTE_NAMES: List[str] = ["ID"]
+    _TEXT_NAMES: List[str] = ["Name"]
+    _CHILDREN_NAMES: List[str] = ["Value"]
+    
+    def __init__(self, data: Dict[str, Any]) -> None:
+        super().__init__(data)
+        if "Value" not in self._data:
+            self._data["Value"] = []
+
+
+class ListOfValuesGroup(BaseObject):
+    """ListOfValuesGroup - hierarchical grouping of lists of values."""
+    _GROUP_NAME: Optional[str] = None  # Used as child element only
+    _TAG_NAME: str = 'ListOfValuesGroup'
+    _ATTRIBUTE_NAMES: List[str] = ["ID", "ParentID", "Selected", "Referenced", "Changed"]
+    _TEXT_NAMES: List[str] = ["Name"]
+    _CHILDREN_NAMES: List[str] = [
+        "MetaData",
+        "AttributeGroupLink",
+        "ListOfValuesGroup"  # Nested groups
+    ]
+    
+    def __init__(self, data: Dict[str, Any]) -> None:
+        super().__init__(data)
+        if "AttributeGroupLink" not in self._data:
+            self._data["AttributeGroupLink"] = []
+        if "ListOfValuesGroup" not in self._data:
+            self._data["ListOfValuesGroup"] = []
+    
+    def add_nested_list_of_values_group(self, group: Optional['ListOfValuesGroup'] = None,
+                                       **kwargs) -> None:
+        """Add nested list of values group.
+        
+        Can be called two ways:
+        1. With object: add_nested_list_of_values_group(group=child_group)
+        2. With parameters: add_nested_list_of_values_group(ID="LOG002", Name="Child")
+        """
+        if group is not None:
+            nested = group
+        else:
+            nested = ListOfValuesGroup(kwargs)
+        
+        if not isinstance(self._data["ListOfValuesGroup"], list):
+            self._data["ListOfValuesGroup"] = []
+        self._data["ListOfValuesGroup"].append(nested)

stepxmlclient/model/business.py

@@ -0,0 +1,233 @@
+"""Business rules and workflow models for STEP XML Client.
+
+Defines business logic execution entities including Business Rules and Workflows
+that control behavior and processes within STEP MDM systems.
+"""
+
+from typing import List, Optional, Any, Dict, TYPE_CHECKING
+from . import BaseObject
+
+if TYPE_CHECKING:
+    pass
+
+
+class BusinessRule(BaseObject):
+    """Business logic executable in STEP MDM.
+    
+    Defines executable business logic including actions, conditions, functions, and libraries.
+    Business rules contain logic that executes within the STEP system to automate processes.
+    
+    Supports:
+    - Multiple rule types (Action, Condition, Function, Library)
+    - Rule scope (Local or Global)
+    - Privileged execution mode
+    - Dependencies on other rules
+    - Multi-language names and descriptions
+    - Setup group configuration
+    
+    Attributes:
+        ID: Unique business rule identifier
+        Type: Rule type (Action, Condition, Function, Library, etc.)
+        Scope: Scope of execution (Local or Global)
+        RunPrivileged: Whether to run with elevated privileges
+        Name: Rule name (localized)
+        Description: Rule description (localized)
+        Dependency: List of dependent rules
+        FunctionDependency: List of function dependencies
+        OnApprove: On-approval behavior configuration
+        Configuration: Rule-specific configuration
+        ValidObjectTypes: Object types this rule applies to
+        SetupGroupLink: Link to setup groups
+    """
+    _GROUP_NAME: str = 'businessrules'
+    _TAG_NAME: str = 'BusinessRule'
+    _ATTRIBUTE_NAMES: List[str] = ["ID", "Type", "Scope", "RunPrivileged", "Selected", "Referenced", "Changed"]
+    _TEXT_NAMES: List[str] = ["Name", "Description"]
+    _CHILDREN_NAMES: List[str] = [
+        "Dependency",
+        "FunctionDependency",
+        "OnApprove",
+        "Configuration",
+        "ValidObjectTypes",
+        "SetupGroupLink"
+    ]
+    
+    def __init__(self, data: Dict[str, Any]) -> None:
+        super().__init__(data)
+        # Initialize dependency lists if not provided
+        for dep_name in ["Dependency", "FunctionDependency"]:
+            if dep_name not in self._data:
+                self._data[dep_name] = []
+
+
+class Workflow(BaseObject):
+    """Workflow - orchestrates business processes in STEP.
+    
+    Workflows define states, transitions, and validations that control how objects
+    move through business processes. Workflows enforce rules about what operations
+    are allowed in each state and what data must be valid before transitions.
+    
+    Supports:
+    - Object type constraints (ValidUserTypeLink)
+    - Start conditions
+    - Embedded business rules
+    - Business rule references
+    - Setup group configuration
+    - Multi-language names
+    - Boolean state tracking (Selected, Referenced, Changed)
+    
+    Attributes:
+        ID: Unique workflow identifier
+        Name: Workflow name (localized)
+        Description: Workflow description
+        ValidUserTypeLink: Links to object types this workflow applies to
+        ValidBusinessRuleLink: Links to relevant business rules
+        StartCondition: Condition for workflow start
+        STEPAction: Workflow actions
+        STEPState: Workflow states
+        STEPEdge: State transitions
+        SetupGroupLink: Setup group associations
+    """
+    _GROUP_NAME: str = 'workflows'
+    _TAG_NAME: str = 'Workflow'
+    _ATTRIBUTE_NAMES: List[str] = ["ID", "Selected", "Referenced", "Changed"]
+    _TEXT_NAMES: List[str] = ["Name"]
+    _CHILDREN_NAMES: List[str] = [
+        "MetaData",
+        "ValidUserTypeLink",
+        "StartCondition",
+        "Configuration",
+        "LocalBusinessRule",
+        "BusinessRuleLink",
+        "SetupGroupLink"
+    ]
+    
+    def __init__(self, data: Dict[str, Any]) -> None:
+        super().__init__(data)
+        # Initialize link lists if not provided
+        for link_name in ["ValidUserTypeLink", "LocalBusinessRule", "BusinessRuleLink"]:
+            if link_name not in self._data:
+                self._data[link_name] = []
+    
+    def add_valid_user_type_link(self, user_type_id: str) -> None:
+        """Add a valid user type link to this workflow.
+        
+        Args:
+            user_type_id: ID of the user type
+        """
+        if not isinstance(self._data["ValidUserTypeLink"], list):
+            self._data["ValidUserTypeLink"] = []
+        self._data["ValidUserTypeLink"].append(user_type_id)
+    
+    def add_business_rule_link(self, business_rule_id: str) -> None:
+        """Add a business rule link to this workflow.
+        
+        Args:
+            business_rule_id: ID of the business rule
+        """
+        if not isinstance(self._data["BusinessRuleLink"], list):
+            self._data["BusinessRuleLink"] = []
+        self._data["BusinessRuleLink"].append(business_rule_id)
+
+
+class Collection(BaseObject):
+    """Collection - represents a user-defined collection of objects.
+    
+    Collections group objects based on queries or manual selection.
+    They provide flexible organization outside fixed hierarchies.
+    
+    Supports:
+    - Query-based membership (QueryURL)
+    - Parent collection linking for hierarchies
+    - Multi-language names
+    - Metadata tracking
+    """
+    _GROUP_NAME: str = 'collections'
+    _TAG_NAME: str = 'Collection'
+    _ATTRIBUTE_NAMES: List[str] = ["ID", "ParentID", "QueryURL"]
+    _TEXT_NAMES: List[str] = ["Name"]
+    _CHILDREN_NAMES: List[str] = ["MetaData", "CollectionGroup"]
+    
+    def __init__(self, data: Dict[str, Any]) -> None:
+        super().__init__(data)
+        # Initialize nested collection groups list
+        if "CollectionGroup" not in self._data:
+            self._data["CollectionGroup"] = []
+    
+    def add_nested_collection_group(self, collection_group: Optional['CollectionGroup'] = None,
+                                   **kwargs) -> None:
+        """Add nested collection group.
+        
+        Can be called two ways:
+        1. With object: add_nested_collection_group(collection_group=group_obj)
+        2. With parameters: add_nested_collection_group(ID="CG001", Name="Group")
+        """
+        if collection_group is not None:
+            group = collection_group
+        else:
+            group = CollectionGroup(kwargs)
+        
+        if not isinstance(self._data["CollectionGroup"], list):
+            self._data["CollectionGroup"] = []
+        self._data["CollectionGroup"].append(group)
+
+
+class CollectionGroup(BaseObject):
+    """CollectionGroup - hierarchical grouping of collections.
+    
+    Collection groups organize collections and nested groups into
+    logical hierarchies for better navigation and management.
+    
+    Supports:
+    - Nested collection groups (parent/child hierarchy)
+    - Nested collections
+    - Multi-language names
+    - Metadata tracking
+    """
+    _GROUP_NAME: str = 'collectiongroups'
+    _TAG_NAME: str = 'CollectionGroup'
+    _ATTRIBUTE_NAMES: List[str] = ["ID", "ParentID"]
+    _TEXT_NAMES: List[str] = ["Name"]
+    _CHILDREN_NAMES: List[str] = ["MetaData", "CollectionGroup", "Collection"]
+    
+    def __init__(self, data: Dict[str, Any]) -> None:
+        super().__init__(data)
+        # Initialize nested groups and collections lists
+        if "CollectionGroup" not in self._data:
+            self._data["CollectionGroup"] = []
+        if "Collection" not in self._data:
+            self._data["Collection"] = []
+    
+    def add_nested_collection_group(self, collection_group: Optional['CollectionGroup'] = None,
+                                   **kwargs) -> None:
+        """Add nested collection group.
+        
+        Can be called two ways:
+        1. With object: add_nested_collection_group(collection_group=group_obj)
+        2. With parameters: add_nested_collection_group(ID="CG002", Name="Nested")
+        """
+        if collection_group is not None:
+            group = collection_group
+        else:
+            group = CollectionGroup(kwargs)
+        
+        if not isinstance(self._data["CollectionGroup"], list):
+            self._data["CollectionGroup"] = []
+        self._data["CollectionGroup"].append(group)
+    
+    def add_collection(self, collection: Optional['Collection'] = None,
+                      **kwargs) -> None:
+        """Add a collection to this group.
+        
+        Can be called two ways:
+        1. With object: add_collection(collection=coll_obj)
+        2. With parameters: add_collection(ID="C001", Name="Collection Name")
+        """
+        if collection is not None:
+            coll = collection
+        else:
+            coll = Collection(kwargs)
+        
+        if not isinstance(self._data["Collection"], list):
+            self._data["Collection"] = []
+        self._data["Collection"].append(coll)