stepxmlclient 1.0.0__py3-none-any.whl

stepxmlclient/model/deletion.py

@@ -0,0 +1,87 @@
+"""Deletion models for STEP XML Client.
+
+Defines entity and cross-reference deletion classes for removing items from STEP MDM.
+Supports both full entity deletion and link severance operations.
+"""
+
+from typing import List, Optional
+from . import BaseObject
+
+class DeleteAsset(BaseObject):
+    """Top-level deletion specification for assets.
+    
+    Moves an asset to the recycle bin. The asset and all its associated data is marked for deletion.
+    
+    Attributes:
+        ID: Asset ID to delete
+        KeyValue: Optional key value reference
+    """
+    _GROUP_NAME: str = 'deletedassets'
+    _TAG_NAME: str = 'DeleteAsset'
+    _ATTRIBUTE_NAMES: List[str] = ["ID"]
+    _TEXT_NAMES: List[str] = []
+    _CHILDREN_NAMES: List[str] = ["KeyValue"]
+
+
+class DeleteProduct(BaseObject):
+    """Top-level deletion specification for products.
+    
+    Moves a product to the recycle bin. The product and all its associated data is marked for deletion.
+    
+    Attributes:
+        ID: Product ID to delete
+        KeyValue: Optional key value reference
+    """
+    _GROUP_NAME: str = 'deletedproducts'
+    _TAG_NAME: str = 'DeleteProduct'
+    _ATTRIBUTE_NAMES: List[str] = ["ID"]
+    _TEXT_NAMES: List[str] = []
+    _CHILDREN_NAMES: List[str] = ["KeyValue"]
+
+
+class DeleteAssetCrossReference(BaseObject):
+    """Deletion specification for asset cross-references.
+    
+    Severs the link between an asset and a product while keeping both items intact.
+    The product remains but the asset reference is removed.
+    
+    Attributes:
+        AssetID: Asset ID of the link to sever
+        Type: Link type
+        QualifierID: Optional qualifier
+        Changed: Whether changed
+        KeyValue: Optional key value reference
+        MetaData: Optional metadata
+    """
+    _GROUP_NAME: Optional[str] = None  # Used as child element only
+    _TAG_NAME: str = 'DeleteAssetCrossReference'
+    _ATTRIBUTE_NAMES: List[str] = ["AssetID", "Type", "QualifierID", "Changed"]
+    _TEXT_NAMES: List[str] = []
+    _CHILDREN_NAMES: List[str] = ["KeyValue", "MetaData"]
+
+
+class DeleteProductCrossReference(BaseObject):
+    """Delete/sever product link from another product while keeping both intact."""
+    _GROUP_NAME: Optional[str] = None  # Used as child element only
+    _TAG_NAME: str = 'DeleteProductCrossReference'
+    _ATTRIBUTE_NAMES: List[str] = ["ProductID", "Type", "QualifierID", "MountLocation", "Changed"]
+    _TEXT_NAMES: List[str] = []
+    _CHILDREN_NAMES: List[str] = ["KeyValue", "MetaData"]
+
+
+class DeleteClassificationCrossReference(BaseObject):
+    """Delete/sever classification link while keeping classification intact."""
+    _GROUP_NAME: Optional[str] = None  # Used as child element only
+    _TAG_NAME: str = 'DeleteClassificationCrossReference'
+    _ATTRIBUTE_NAMES: List[str] = ["ClassificationID", "Type", "QualifierID", "Changed"]
+    _TEXT_NAMES: List[str] = []
+    _CHILDREN_NAMES: List[str] = ["KeyValue", "MetaData"]
+
+
+class DeleteEntityCrossReference(BaseObject):
+    """Delete/sever entity link while keeping entity intact."""
+    _GROUP_NAME: Optional[str] = None  # Used as child element only
+    _TAG_NAME: str = 'DeleteEntityCrossReference'
+    _ATTRIBUTE_NAMES: List[str] = ["EntityID", "Type", "QualifierID", "Changed"]
+    _TEXT_NAMES: List[str] = []
+    _CHILDREN_NAMES: List[str] = ["KeyValue", "MetaData"]

stepxmlclient/model/entity.py

@@ -0,0 +1,368 @@
+"""Entity model for STEP XML Client.
+
+Defines the Entity class for representing generic MDM objects in STEP.
+Entities provide a flexible structure for modeling various types of business objects beyond
+products, classifications, and assets.
+"""
+
+from typing import List, Optional, Any, Dict, TYPE_CHECKING
+from . import BaseObject
+
+if TYPE_CHECKING:
+    from .relations import ProductCrossReference, ClassificationCrossReference, EntityCrossReference, AssetCrossReference
+    from .deletion import DeleteProductCrossReference, DeleteClassificationCrossReference, DeleteEntityCrossReference, DeleteAssetCrossReference
+    from .complex_elements import CurrentTasks, Task, Terms, Term
+
+
+class Entity(BaseObject):
+    """Entity model in STEP MDM.
+
+    Common ``data`` keys:
+    - ``ID``, ``ParentID``, ``UserTypeID``, ``QualifierID``
+    - ``Name``
+    - ``KeyValue`` / ``ParentKeyValue``
+    - ``Values`` and ``DataContainers``
+
+    Supports cross-references and also ``CurrentTasks`` / ``Terms`` children.
+
+    Usage examples:
+        Dict-first style::
+
+            entity = Entity({"ID": "E100", "UserTypeID": "UT_ENTITY"})
+            entity.add_product_reference(product_id="P100", type_="Owner")
+            entity.add_term({"TermsListID": "NET", "value": "Net 30"})
+
+        Pre-built object style::
+
+            from stepxmlclient.model import Task, Terms, Term
+            entity = Entity({"ID": "E101", "UserTypeID": "UT_ENTITY"})
+            entity.add_current_task(task_object=Task({
+                "STEPWorkflowID": "WF2",
+                "StateID": "S2",
+                "AssigneeID": "U2",
+                "AssignedToGroup": False,
+                "EntryTime": "2026-02-02T00:00:00Z",
+            }))
+            entity.add_term(terms_object=Terms({"Term": [Term({"TermsListID": "T1", "value": "Immediate"})]}))
+    """
+    _GROUP_NAME: str = 'entities'
+    _TAG_NAME: str = 'Entity'
+    _ATTRIBUTE_NAMES: List[str] = ["ID", "ParentID", "UserTypeID", "QualifierID", "Changed", "Republished", "Selected", "Referenced"]
+    _TEXT_NAMES: List[str] = ["Name"]
+    _CHILDREN_NAMES: List[str] = [
+        "KeyValue",
+        "ParentKeyValue",
+        "Entity",  # Nested entities
+        "DeleteSuppressedClassificationCrossReference",
+        "DeleteClassificationCrossReference",
+        "SuppressedClassificationCrossReference",
+        "ClassificationCrossReference",
+        "DeleteSuppressedProductCrossReference",
+        "DeleteProductCrossReference",
+        "SuppressedProductCrossReference",
+        "ProductCrossReference",
+        "DeleteSuppressedAssetCrossReference",
+        "DeleteAssetCrossReference",
+        "SuppressedAssetCrossReference",
+        "AssetCrossReference",
+        "DeleteSuppressedEntityCrossReference",
+        "DeleteEntityCrossReference",
+        "SuppressedEntityCrossReference",
+        "EntityCrossReference",
+        "SuppressedContextCrossReference",
+        "ContextCrossReference",
+        "SuppressedWorkspaceCrossReference",
+        "WorkspaceCrossReference",
+        "Values",
+        "DataContainers",
+        "CurrentTasks",
+        "Terms"
+    ]
+    
+    def __init__(self, data: Dict[str, Any]) -> None:
+        super().__init__(data)
+        # Initialize relation lists if not provided
+        for rel_name in ["ProductCrossReference", "DeleteProductCrossReference",
+                        "SuppressedProductCrossReference", "DeleteSuppressedProductCrossReference",
+                        "ClassificationCrossReference", "DeleteClassificationCrossReference",
+                        "SuppressedClassificationCrossReference", "DeleteSuppressedClassificationCrossReference",
+                        "EntityCrossReference", "DeleteEntityCrossReference",
+                        "SuppressedEntityCrossReference", "DeleteSuppressedEntityCrossReference",
+                        "AssetCrossReference", "DeleteAssetCrossReference",
+                        "SuppressedAssetCrossReference", "DeleteSuppressedAssetCrossReference",
+                        "ContextCrossReference", "SuppressedContextCrossReference",
+                        "WorkspaceCrossReference", "SuppressedWorkspaceCrossReference",
+                        "Values", "DataContainers", "CurrentTasks", "Terms"]:
+            if rel_name not in self._data:
+                self._data[rel_name] = []
+        
+        # Initialize nested entities list
+        if "Entity" not in self._data:
+            self._data["Entity"] = []
+    
+    # ===== Product Cross-Reference Methods =====
+    
+    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 ``ProductCrossReference``.
+
+        Fields: ``ProductID``, ``Type``, ``QualifierID``, ``MountLocation``.
+        """
+        from .relations import ProductCrossReference
+        
+        if ref_object is not None:
+            ref = ref_object
+        else:
+            ref = 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``.
+
+        Fields: ``ProductID``, ``Type``, ``QualifierID``, ``MountLocation``.
+        """
+        from .deletion import DeleteProductCrossReference
+        
+        if delete_ref_object is not None:
+            delete_ref = delete_ref_object
+        else:
+            delete_ref = 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)
+    
+    # ===== Classification Cross-Reference Methods =====
+    
+    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['ClassificationCrossReference'] = None) -> None:
+        """Add ``ClassificationCrossReference``.
+
+        Fields: ``ClassificationID``, ``Type``, ``QualifierID``,
+        ``MountLocation``.
+        """
+        from .relations import ClassificationCrossReference
+        
+        if ref_object is not None:
+            ref = ref_object
+        else:
+            ref = 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 delete_classification_reference(self, classification_id: Optional[str] = None,
+                                      type_: Optional[str] = None,
+                                      qualifier_id: Optional[str] = None,
+                                      mount_location: Optional[str] = None,
+                                      delete_ref_object: Optional['DeleteClassificationCrossReference'] = None) -> None:
+        """Add ``DeleteClassificationCrossReference``.
+
+        Fields: ``ClassificationID``, ``Type``, ``QualifierID``,
+        ``MountLocation``.
+        """
+        from .deletion import DeleteClassificationCrossReference
+        
+        if delete_ref_object is not None:
+            delete_ref = delete_ref_object
+        else:
+            delete_ref = DeleteClassificationCrossReference({
+                "ClassificationID": classification_id,
+                "Type": type_,
+                "QualifierID": qualifier_id,
+                "MountLocation": mount_location
+            })
+        
+        if not isinstance(self._data["DeleteClassificationCrossReference"], list):
+            self._data["DeleteClassificationCrossReference"] = []
+        self._data["DeleteClassificationCrossReference"].append(delete_ref)
+    
+    # ===== Entity Cross-Reference Methods =====
+    
+    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
+        
+        if ref_object is not None:
+            ref = ref_object
+        else:
+            ref = 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 delete_entity_reference(self, entity_id: Optional[str] = None,
+                              type_: Optional[str] = None,
+                              qualifier_id: Optional[str] = None,
+                              mount_location: Optional[str] = None,
+                              delete_ref_object: Optional['DeleteEntityCrossReference'] = None) -> None:
+        """Add ``DeleteEntityCrossReference``.
+
+        Fields: ``EntityID``, ``Type``, ``QualifierID``, ``MountLocation``.
+        """
+        from .deletion import DeleteEntityCrossReference
+        
+        if delete_ref_object is not None:
+            delete_ref = delete_ref_object
+        else:
+            delete_ref = DeleteEntityCrossReference({
+                "EntityID": entity_id,
+                "Type": type_,
+                "QualifierID": qualifier_id,
+                "MountLocation": mount_location
+            })
+        
+        if not isinstance(self._data["DeleteEntityCrossReference"], list):
+            self._data["DeleteEntityCrossReference"] = []
+        self._data["DeleteEntityCrossReference"].append(delete_ref)
+    
+    # ===== Asset Cross-Reference Methods =====
+    
+    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 ``AssetCrossReference``.
+
+        Fields: ``AssetID``, ``Type``, ``QualifierID``.
+        """
+        from .relations import AssetCrossReference
+        
+        if ref_object is not None:
+            ref = ref_object
+        else:
+            ref = 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``.
+
+        Fields: ``AssetID``, ``Type``, ``QualifierID``.
+        """
+        from .deletion import DeleteAssetCrossReference
+        
+        if delete_ref_object is not None:
+            delete_ref = delete_ref_object
+        else:
+            delete_ref = 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)
+    
+    # ===== Nested Entity Methods =====
+    
+    def add_nested_entity(self, entity: Optional['Entity'] = None,
+                         **kwargs) -> None:
+        """Add nested ``Entity`` object.
+
+        Pass either ``entity`` or kwargs for ``Entity(...)``.
+        """
+        if entity is not None:
+            nested = entity
+        else:
+            nested = Entity(kwargs)
+        
+        if not isinstance(self._data["Entity"], list):
+            self._data["Entity"] = []
+        self._data["Entity"].append(nested)
+
+    def add_current_task(self,
+                         task_data: Optional[Dict[str, Any]] = None,
+                         task_object: Optional['Task'] = None,
+                         current_tasks_object: Optional['CurrentTasks'] = None) -> None:
+        """Add ``CurrentTasks`` with task entries.
+
+        Task keys: ``STEPWorkflowID``, ``StateID``, ``AssigneeID``,
+        ``AssignedToGroup``, ``EntryTime``, optional ``Deadline``, ``Priority``,
+        ``StatusID``.
+        """
+        from .complex_elements import CurrentTasks, Task
+
+        if current_tasks_object is not None:
+            entry: Any = current_tasks_object
+        else:
+            task = task_object or Task(task_data or {})
+            entry = CurrentTasks({"Task": [task]})
+
+        if not isinstance(self._data.get("CurrentTasks"), list):
+            self._data["CurrentTasks"] = []
+        self._data["CurrentTasks"].append(entry)
+
+    def add_term(self,
+                 term_data: Optional[Dict[str, Any]] = None,
+                 term_object: Optional['Term'] = None,
+                 terms_object: Optional['Terms'] = None) -> None:
+        """Add ``Terms`` with one or more term entries.
+
+        Term keys: ``TermsListID``, ``MinimumQuantity``, ``MaximumQuantity``,
+        ``StartDate``, ``EndDate``, ``LeadTime``, ``UnitID``, ``LotSize`` and
+        optional text value via ``value``.
+        """
+        from .complex_elements import Terms, Term
+
+        if terms_object is not None:
+            entry: Any = terms_object
+        else:
+            term = term_object or Term(term_data or {})
+            entry = Terms({"Term": [term]})
+
+        if not isinstance(self._data.get("Terms"), list):
+            self._data["Terms"] = []
+        self._data["Terms"].append(entry)

stepxmlclient/model/metadata.py

@@ -0,0 +1,199 @@
+"""Metadata and configuration models for STEP XML Client.
+
+Defines metadata and configuration classes for STEP MDM systems including user types,
+contexts, qualifiers, dimensions, tags, units, and other configuration elements.
+"""
+
+from typing import List, Optional, Any, Dict, TYPE_CHECKING
+from . import BaseObject
+
+if TYPE_CHECKING:
+    pass
+
+
+class UserType(BaseObject):
+    """User type - object type definition in STEP MDM.
+    
+    User types define customizable object classifications with attributes, validation rules,
+    icons, and category information. User types control the structure and behavior of
+    products, assets, classifications, and entities.
+    
+    Supports:
+    - Multiple names (multi-language)
+    - Custom icons and templates
+    - Attribute and dimension associations
+    - Validation rules
+    - Category classification
+    - Revisability and link policies
+    - Boolean state tracking (Selected, Referenced, Changed, Deleted)
+    
+    Attributes:
+        ID: Unique user type identifier
+        AllowOverlappingTerms: Whether overlapping terms are allowed
+        AllowQuarkTemplate: Support for Quark templates
+        AllowInDesignTemplate: Support for InDesign templates
+        Revisability: Revision tracking policy
+        IsCategory: Whether this type represents a category
+        DefaultProfileConfiguration: Default profile configuration
+        ClassificationOwnsProductLinks: Classification ownership semantics
+        NamePattern: Pattern for naming instances
+        IDPattern: Pattern for ID generation
+        ManuallySorted: Whether instances are manually sorted
+        ReferenceTargetLockPolicy: Link policy
+        Name: User type name (localized)
+        Icon: Icon representation
+        VisibleTermFields: Visible fields for search
+        MetaData: Metadata
+        DimensionLink: Dimension associations
+        UserTypeLink: Links to other user types
+        AttributeLink: Attribute associations
+        Validation: Validation rules
+        MIMEType: Associated MIME types
+    """
+    _GROUP_NAME: str = 'usertypes'
+    _TAG_NAME: str = 'UserType'
+    _ATTRIBUTE_NAMES: List[str] = [
+        "ID", "AllowOverlappingTerms", "AllowQuarkTemplate",
+        "AllowInDesignTemplate", "Revisability", "IsCategory",
+        "DefaultProfileConfiguration", "ClassificationOwnsProductLinks",
+        "NamePattern", "IDPattern", "ManuallySorted",
+        "ReferenceTargetLockPolicy", "Selected", "Referenced",
+        "Changed", "Deleted"
+    ]
+    _TEXT_NAMES: List[str] = ["Name"]
+    _CHILDREN_NAMES: List[str] = [
+        "Icon",
+        "VisibleTermFields",
+        "MetaData",
+        "DimensionLink",
+        "UserTypeLink",
+        "AttributeLink",
+        "Validation",
+        "MIMEType"
+    ]
+    
+    def __init__(self, data: Dict[str, Any]) -> None:
+        super().__init__(data)
+        # Initialize link lists if not provided
+        for link_name in ["DimensionLink", "UserTypeLink", "AttributeLink", "MIMEType"]:
+            if link_name not in self._data:
+                self._data[link_name] = []
+
+
+class LinkType(BaseObject):
+    """LinkType - defines the type of cross-reference between objects.
+    
+    Link types specify valid relationship types (e.g., CA=Classification-to-Attribute,
+    PA=Product-to-Attribute) for organizing cross-references.
+    
+    Simple metadata element with minimal structure.
+    """
+    _GROUP_NAME: str = 'linktypes'
+    _TAG_NAME: str = 'LinkType'
+    _ATTRIBUTE_NAMES: List[str] = ["LinkTypeID"]
+    _TEXT_NAMES: List[str] = []
+    _CHILDREN_NAMES: List[str] = []
+    
+    def __init__(self, data: Dict[str, Any]) -> None:
+        super().__init__(data)
+
+
+class Tag(BaseObject):
+    """Tag - flexible categorization element independent of hierarchies.
+    
+    Tags enable custom classification and filtering of objects
+    outside the standard product/classification hierarchies.
+    
+    Supports:
+    - Multi-language names
+    - Metadata tracking
+    """
+    _GROUP_NAME: str = 'tags'
+    _TAG_NAME: str = 'Tag'
+    _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)
+
+
+class TagGroup(BaseObject):
+    """TagGroup - hierarchical grouping of tags.
+    
+    Organizes tags into logical collections with parent/child relationships.
+    
+    Supports:
+    - Nested tag groups (hierarchies)
+    - Multi-language names
+    - Tag collection
+    - Metadata tracking
+    """
+    _GROUP_NAME: str = 'taggroups'
+    _TAG_NAME: str = 'TagGroup'
+    _ATTRIBUTE_NAMES: List[str] = ["ID"]
+    _TEXT_NAMES: List[str] = ["Name"]
+    _CHILDREN_NAMES: List[str] = ["MetaData", "TagGroup", "Tag"]
+    
+    def __init__(self, data: Dict[str, Any]) -> None:
+        super().__init__(data)
+        # Initialize nested tag groups and tags lists
+        if "TagGroup" not in self._data:
+            self._data["TagGroup"] = []
+        if "Tag" not in self._data:
+            self._data["Tag"] = []
+    
+    def add_nested_tag_group(self, tag_group: Optional['TagGroup'] = None,
+                            **kwargs) -> None:
+        """Add nested tag group.
+        
+        Can be called two ways:
+        1. With object: add_nested_tag_group(tag_group=group_obj)
+        2. With parameters: add_nested_tag_group(ID="TG002", Name="Nested Group")
+        """
+        if tag_group is not None:
+            group = tag_group
+        else:
+            group = TagGroup(kwargs)
+        
+        if not isinstance(self._data["TagGroup"], list):
+            self._data["TagGroup"] = []
+        self._data["TagGroup"].append(group)
+    
+    def add_tag(self, tag: Optional['Tag'] = None,
+               **kwargs) -> None:
+        """Add a tag to this group.
+        
+        Can be called two ways:
+        1. With object: add_tag(tag=tag_obj)
+        2. With parameters: add_tag(ID="T001", Name="Tag Name")
+        """
+        if tag is not None:
+            t = tag
+        else:
+            t = Tag(kwargs)
+        
+        if not isinstance(self._data["Tag"], list):
+            self._data["Tag"] = []
+        self._data["Tag"].append(t)
+
+
+class Unit(BaseObject):
+    """Unit - defines a measurement unit for quantitative attributes.
+    
+    Units represent measurement standards (meters, kilograms, liters, etc.)
+    used for quantitative attribute values.
+    
+    Supports:
+    - Unit symbol (m, kg, l, etc.)
+    - Conversion formula to base unit
+    - Metadata tracking
+    """
+    _GROUP_NAME: str = 'units'
+    _TAG_NAME: str = 'Unit'
+    _ATTRIBUTE_NAMES: List[str] = ["ID", "Name", "Symbol", "Formula"]
+    _TEXT_NAMES: List[str] = []
+    _CHILDREN_NAMES: List[str] = ["MetaData"]
+    
+    def __init__(self, data: Dict[str, Any]) -> None:
+        super().__init__(data)