stepxmlclient 1.0.0__py3-none-any.whl

stepxmlclient/rest_client/models/__init__.py

@@ -0,0 +1,175 @@
+"""REST API models for STEP REST API v2.
+
+Provides Pydantic models for request/response handling and validation.
+"""
+
+from .common import (
+    PageInfo,
+    PagedResponse,
+    ErrorDetail,
+    ErrorResponse,
+    ApiResponse,
+    SearchFilter,
+    SearchRequest,
+    SuccessResponse,
+    ListResponse,
+)
+from .product import (
+    ProductResponse,
+    ProductListResponse,
+    ProductSearchRequest,
+    ProductCreateRequest,
+    ProductUpdateRequest,
+)
+from .asset import (
+    AssetResponse,
+    AssetListResponse,
+    AssetSearchRequest,
+    AssetCreateRequest,
+    AssetUpdateRequest,
+    AssetUploadRequest,
+    AssetDownloadResponse,
+    AssetMetadata,
+)
+from .classification import (
+    ClassificationResponse,
+    ClassificationListResponse,
+    ClassificationCreateRequest,
+    ClassificationUpdateRequest,
+)
+from .entity import (
+    EntityResponse,
+    EntityListResponse,
+    EntityCreateRequest,
+    EntityUpdateRequest,
+    EntityRelationshipResponse,
+)
+from .attribute import (
+    AttributeResponse,
+    AttributeMetadata,
+    AttributeValue,
+    ListOfValueResponse,
+    ListOfValueItem,
+)
+from .import_export import (
+    BackgroundProcessResponse,
+    ExportJobCreateRequest,
+)
+from .relations import (
+    RelationshipTypeResponse,
+    RelationshipResponse,
+    RelationshipListResponse,
+    RelationshipCreateRequest,
+    RelationshipUpdateRequest,
+    CrossReferenceResponse,
+    CrossReferenceListResponse,
+    CrossReferenceCreateRequest,
+    LinkResponse,
+    LinkListResponse,
+    LinkCreateRequest,
+    RelationshipGraphResponse,
+)
+from .context import (
+    ContextResponse,
+)
+from .system_information import (
+    SystemInformationResponse,
+)
+from .user import (
+    UserResponse,
+    UserGroupResponse,
+)
+from .collection import (
+    CollectionResponse,
+    CollectionGroupResponse,
+)
+from .background_process import (
+    BackgroundProcessResponse,
+)
+from .event_processor import (
+    EventProcessorResponse,
+)
+from .integration_endpoint import (
+    IntegrationEndpointResponse,
+)
+from .workflow import (
+    WorkflowResponse,
+    WorkflowTaskResponse,
+)
+from .batch import (
+    BatchRequest,
+    BatchResponse,
+    OperationRequest,
+    OperationResponse,
+)
+from .data_type_group import (
+    DataTypeGroupResponse,
+)
+
+__all__ = [
+    'PageInfo',
+    'PagedResponse',
+    'ErrorDetail',
+    'ErrorResponse',
+    'ApiResponse',
+    'SearchFilter',
+    'SearchRequest',
+    'SuccessResponse',
+    'ListResponse',
+    'ProductResponse',
+    'ProductListResponse',
+    'ProductSearchRequest',
+    'ProductCreateRequest',
+    'ProductUpdateRequest',
+    'AssetResponse',
+    'AssetListResponse',
+    'AssetSearchRequest',
+    'AssetCreateRequest',
+    'AssetUpdateRequest',
+    'AssetUploadRequest',
+    'AssetDownloadResponse',
+    'AssetMetadata',
+    'ClassificationResponse',
+    'ClassificationListResponse',
+    'ClassificationCreateRequest',
+    'ClassificationUpdateRequest',
+    'EntityResponse',
+    'EntityListResponse',
+    'EntityCreateRequest',
+    'EntityUpdateRequest',
+    'EntityRelationshipResponse',
+    'AttributeResponse',
+    'AttributeMetadata',
+    'AttributeValue',
+    'ListOfValueResponse',
+    'ListOfValueItem',
+    'BackgroundProcessResponse',
+    'ExportJobCreateRequest',
+    'RelationshipTypeResponse',
+    'RelationshipResponse',
+    'RelationshipListResponse',
+    'RelationshipCreateRequest',
+    'RelationshipUpdateRequest',
+    'CrossReferenceResponse',
+    'CrossReferenceListResponse',
+    'CrossReferenceCreateRequest',
+    'LinkResponse',
+    'LinkListResponse',
+    'LinkCreateRequest',
+    'RelationshipGraphResponse',
+    'WorkflowResponse',
+    'WorkflowTaskResponse',
+    'ContextResponse',
+    'SystemInformationResponse',
+    'UserResponse',
+    'UserGroupResponse',
+    'CollectionResponse',
+    'CollectionGroupResponse',
+    'EventProcessorResponse',
+    'IntegrationEndpointResponse',
+    'BatchRequest',
+    'BatchResponse',
+    'OperationRequest',
+    'OperationResponse',
+    'DataTypeGroupResponse',
+]

stepxmlclient/rest_client/models/asset.py

@@ -0,0 +1,253 @@
+"""Asset-related REST API models.
+
+Provides Pydantic models aligned with STEP REST API v2 asset schemas.
+"""
+
+from typing import Any, Dict, List, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class AssetMetadata(BaseModel):
+    """Asset file metadata.
+    
+    Attributes:
+        filename: Original filename
+        mime_type: MIME type (e.g., "image/jpeg")
+        size: File size in bytes
+        creation_date: Upload/creation timestamp
+        modification_date: Last modification timestamp
+        checksum: File checksum for integrity verification
+    """
+    
+    filename: str | None = Field(None, description="Original filename")
+    mime_type: str | None = Field(None, description="MIME type")
+    size: Optional[int] = Field(None, ge=0, description="File size in bytes")
+    creation_date: str | None = Field(None, description="Creation timestamp")
+    modification_date: str | None = Field(None, description="Modification timestamp")
+    checksum: str | None = Field(None, description="File checksum")
+
+
+class AssetResponse(BaseModel):
+    """Single asset response data.
+
+    Mirrors the REST API Asset schema:
+    - objectType/classifications describe placement and type
+    - values/references are dynamic maps keyed by ID
+    - contentMetadata is read-only metadata returned by STEP
+    """
+    
+    model_config = ConfigDict(
+        json_schema_extra={
+            "example": {
+                "id": "ASSET123",
+                "objectType": "ProductImage",
+                "name": "Product Image",
+                "classifications": ["ProductImageRoot"],
+                "values": {
+                    "AssetKeywords": {
+                        "values": [
+                            {"value": "TV"},
+                            {"value": "Television"}
+                        ]
+                    }
+                },
+                "references": {},
+                "contentMetadata": {
+                    "originalFilename": "product.jpg",
+                    "mimeType": "image/jpeg"
+                }
+            }
+        }
+    )
+
+    id: str = Field(..., description="Asset ID")
+    objectType: str | None = Field(None, description="Object type ID")
+    name: str | None = Field(None, description="Asset name/description")
+    classifications: Optional[List[str]] = Field(default_factory=list, description="Linked classification IDs")
+    values: Optional[Dict[str, Any]] = Field(None, description="Asset values keyed by attribute ID")
+    references: Optional[Dict[str, Any]] = Field(None, description="Asset references keyed by reference type ID")
+    contentMetadata: Optional[Dict[str, str]] = Field(None, description="Read-only asset content metadata")
+
+
+class AssetListResponse(BaseModel):
+    """Paginated asset list response.
+    
+    Attributes:
+        items: List of AssetResponse objects
+        total: Total number of assets
+        limit: Items per page
+        offset: Current offset
+        has_more: Whether more results are available
+    """
+    
+    model_config = ConfigDict(
+        json_schema_extra={
+            "example": {
+                "items": [],
+                "total": 50,
+                "limit": 20,
+                "offset": 0,
+                "has_more": True
+            }
+        }
+    )
+    
+    items: List[AssetResponse] = Field(default_factory=list, description="Assets in this page")
+    total: Optional[int] = Field(None, ge=0, description="Total number of assets")
+    limit: int = Field(20, ge=1, le=1000, description="Items per page")
+    offset: int = Field(0, ge=0, description="Current offset")
+    has_more: bool = Field(False, description="Whether more results are available")
+
+
+class AssetSearchRequest(BaseModel):
+    """Search request for assets.
+    
+    Attributes:
+        query: Free-text search query
+        object_type: Filter by object type
+        modified_since: Only assets modified after this date (ISO 8601)
+        limit: Max results to return
+        offset: Result offset for pagination
+        include_metadata: Whether to include metadata
+        include_content: Whether to include binary content reference
+    """
+    
+    model_config = ConfigDict(
+        json_schema_extra={
+            "example": {
+                "query": "*",
+                "object_type": "ProductImage",
+                "limit": 20,
+                "offset": 0,
+                "include_metadata": True
+            }
+        }
+    )
+    
+    query: str = Field("*", description="Free-text search query")
+    object_type: str | None = Field(None, description="Filter by object type")
+    modified_since: str | None = Field(None, description="ISO 8601 timestamp filter")
+    limit: int = Field(20, ge=1, le=1000, description="Max results")
+    offset: int = Field(0, ge=0, description="Result offset")
+    include_metadata: bool = Field(True, description="Include metadata")
+    include_content: bool = Field(False, description="Include content reference")
+
+
+class AssetCreateRequest(BaseModel):
+    """Request to create a new asset.
+
+    Attributes:
+        objectType: Asset object type (required)
+        classifications: Classification IDs to link asset into (required, min 1)
+        name: Asset name/description
+        values: Asset values map keyed by attribute ID
+        references: Asset references map keyed by reference/link type ID
+    """
+
+    model_config = ConfigDict(
+        json_schema_extra={
+            "example": {
+                "objectType": "ProductImage",
+                "classifications": ["ProductImageRoot"],
+                "name": "New Asset",
+                "values": {
+                    "AssetKeywords": {
+                        "values": [{"value": "TV"}]
+                    }
+                }
+            }
+        }
+    )
+
+    objectType: str = Field(..., description="Object type ID")
+    classifications: List[str] = Field(..., min_length=1, description="Parent classification IDs")
+    name: str | None = Field(None, description="Asset name/description")
+    values: Optional[Dict[str, Any]] = Field(None, description="Asset values")
+    references: Optional[Dict[str, Any]] = Field(None, description="Asset references")
+
+
+class AssetUpdateRequest(BaseModel):
+    """Request to update an existing asset.
+    
+    Attributes:
+        name: Updated asset name/description
+        classifications: Classifications to add
+        values: Updated asset values
+        references: Updated references
+    """
+    
+    model_config = ConfigDict(
+        json_schema_extra={
+            "example": {
+                "name": "Updated Asset Name",
+                "classifications": ["ProductImageRoot"],
+                "values": {
+                    "AssetKeywords": {
+                        "values": [{"value": "TV"}]
+                    }
+                }
+            }
+        }
+    )
+
+    name: str | None = Field(None, description="Updated asset name")
+    classifications: Optional[List[str]] = Field(None, description="Classifications to add")
+    values: Optional[Dict[str, Any]] = Field(None, description="Values to update")
+    references: Optional[Dict[str, Any]] = Field(None, description="References to update")
+
+
+class AssetUploadRequest(BaseModel):
+    """Request to upload asset binary content.
+    
+    Attributes:
+        filename: Filename for the uploaded content
+        mime_type: MIME type of the content (e.g., "image/jpeg")
+        file_path: Local file path (used in API calls, not in model)
+        description: Optional description of the upload
+    """
+    
+    model_config = ConfigDict(
+        json_schema_extra={
+            "example": {
+                "filename": "product.jpg",
+                "mime_type": "image/jpeg",
+                "description": "Product catalog image"
+            }
+        }
+    )
+    
+    filename: str = Field(..., description="Filename for uploaded content")
+    mime_type: str = Field(..., description="MIME type")
+    description: str | None = Field(None, description="Upload description")
+
+
+class AssetDownloadResponse(BaseModel):
+    """Response for asset binary download.
+    
+    Attributes:
+        asset_id: Asset ID being downloaded
+        filename: Downloaded filename
+        size: File size in bytes
+        mime_type: MIME type of content
+        content_url: URL to download content (if applicable)
+        expires_at: Expiration time of download URL (if applicable)
+    """
+    
+    model_config = ConfigDict(
+        json_schema_extra={
+            "example": {
+                "asset_id": "ASSET123",
+                "filename": "product.jpg",
+                "size": 102400,
+                "mime_type": "image/jpeg"
+            }
+        }
+    )
+    
+    asset_id: str = Field(..., description="Asset ID")
+    filename: str | None = Field(None, description="Downloaded filename")
+    size: Optional[int] = Field(None, ge=0, description="File size in bytes")
+    mime_type: str | None = Field(None, description="MIME type")
+    content_url: str | None = Field(None, description="Download URL")
+    expires_at: str | None = Field(None, description="URL expiration time")

stepxmlclient/rest_client/models/attribute.py

@@ -0,0 +1,112 @@
+"""Attribute model classes for STEP REST API v2."""
+
+from typing import Optional, List, Dict, Any
+from pydantic import BaseModel, Field, ConfigDict
+
+
+class AttributeValue(BaseModel):
+    """Individual attribute value."""
+    
+    model_config = ConfigDict(json_schema_extra={
+        "example": {
+            "value": "Blue",
+            "context": "Context1",
+            "language": "en"
+        }
+    })
+    
+    value: Any = Field(..., description="The attribute value")
+    context: str | None = Field(None, description="Context for this value")
+    language: str | None = Field(None, description="Language code")
+
+
+class ListOfValueItem(BaseModel):
+    """Individual item in a List of Values."""
+    
+    model_config = ConfigDict(json_schema_extra={
+        "example": {
+            "id": "LOV_ITEM_001",
+            "name": "Option 1",
+            "description": "First option",
+            "sequence": 1
+        }
+    })
+    
+    id: str = Field(..., description="LOV item ID")
+    name: str = Field(..., description="LOV item name")
+    description: str | None = Field(None, description="LOV item description")
+    sequence: Optional[int] = Field(None, description="Display sequence")
+
+
+class ListOfValueResponse(BaseModel):
+    """Response containing List of Values (maps to STEP ``ListOfValues`` schema).
+
+    The STEP REST API spec defines ``ListOfValues`` with properties:
+    ``id``, ``name``, ``extendable``, ``usesValueIds``, ``values``.
+    All fields are optional (``required: []`` in spec).
+    The collection field in the spec is ``values``, not ``items``.
+    """
+
+    model_config = ConfigDict(populate_by_name=True, json_schema_extra={
+        "example": {
+            "id": "LOV_001",
+            "name": "Color LOV",
+            "extendable": False,
+            "usesValueIds": True,
+            "values": [{"id": "LOV_ITEM_001", "name": "Red"}]
+        }
+    })
+
+    id: str | None = Field(None, description="LOV ID")
+    name: str | None = Field(None, description="LOV name")
+    extendable: Optional[bool] = Field(None, description="Whether users can extend the LOV")
+    usesValueIds: Optional[bool] = Field(None, description="Whether values have explicit IDs")
+    values: Optional[List[ListOfValueItem]] = Field(None, description="List of values (spec field name)")
+    # Backward-compatible alias — some callers may have used 'items'
+    items: Optional[List[ListOfValueItem]] = Field(None, description="Alias for values (legacy field name)")
+    total: Optional[int] = Field(None, description="Total number of items")
+
+
+class AttributeMetadata(BaseModel):
+    """Metadata about an attribute."""
+    
+    model_config = ConfigDict(json_schema_extra={
+        "example": {
+            "type": "Text",
+            "required": True,
+            "multiValued": False,
+            "createdAt": "2025-01-01T00:00:00Z",
+            "modifiedAt": "2025-01-02T00:00:00Z"
+        }
+    })
+    
+    type: str = Field(..., description="Attribute data type (Text, Number, Boolean, etc.)")
+    required: Optional[bool] = Field(None, description="Whether attribute is required")
+    multiValued: Optional[bool] = Field(None, description="Whether attribute supports multiple values")
+    createdAt: str | None = Field(None, description="Creation timestamp")
+    modifiedAt: str | None = Field(None, description="Last modification timestamp")
+
+
+class AttributeResponse(BaseModel):
+    """Response from attribute GET operation."""
+    
+    model_config = ConfigDict(json_schema_extra={
+        "example": {
+            "id": "ATTR_001",
+            "name": "Color",
+            "type": "Text",
+            "required": True,
+            "lovId": "LOV_001",
+            "metadata": {"type": "Text"}
+        }
+    })
+    
+    id: str = Field(..., description="Attribute ID")
+    name: str = Field(..., description="Attribute name")
+    description: str | None = Field(None, description="Attribute description")
+    type: str = Field(..., description="Attribute data type")
+    lovId: str | None = Field(None, description="Associated List of Values ID")
+    required: Optional[bool] = Field(None, description="Is required")
+    multiValued: Optional[bool] = Field(None, description="Supports multiple values")
+    metadata: Optional[AttributeMetadata] = Field(None, description="Attribute metadata")
+

stepxmlclient/rest_client/models/background_process.py

@@ -0,0 +1,23 @@
+"""Background process models for STEP REST API v2."""
+
+from typing import Optional
+
+from pydantic import BaseModel, ConfigDict
+
+
+class BackgroundProcessResponse(BaseModel):
+    """STEP background process status representation."""
+    model_config = ConfigDict(extra="allow")
+
+    id: str | None = None
+    background_process_type: str | None = None
+    description: str | None = None
+    user: str | None = None
+    status: str | None = None
+    created: str | None = None
+    started: str | None = None
+    ended: str | None = None
+    execution_time_millis: Optional[float] = None
+    number_of_warnings: Optional[int] = None
+    number_of_errors: Optional[int] = None
+    progress: Optional[int] = None

stepxmlclient/rest_client/models/batch.py

@@ -0,0 +1,41 @@
+"""Batch operation models for STEP REST API v2."""
+
+from typing import Any, Optional
+
+from pydantic import BaseModel, ConfigDict
+
+
+class OperationRequest(BaseModel):
+    """Single operation within a batch."""
+    model_config = ConfigDict(extra="allow")
+
+    resource: str
+    method: str
+    query_parameters: Optional[dict[str, Any]] = None
+    body: Optional[dict[str, Any]] = None
+
+
+class BatchRequest(BaseModel):
+    """Batch execution request."""
+    model_config = ConfigDict(extra="allow")
+
+    mode: str | None = "LENIENT"
+    operations: list[OperationRequest]
+
+
+class OperationResponse(BaseModel):
+    """Single operation result within a batch response."""
+    model_config = ConfigDict(extra="allow")
+
+    resource: str | None = None
+    method: str | None = None
+    status: Optional[int] = None
+    body: Optional[dict[str, Any]] = None
+    duration: Optional[int] = None
+
+
+class BatchResponse(BaseModel):
+    """Batch execution response."""
+    model_config = ConfigDict(extra="allow")
+
+    results: Optional[list[OperationResponse]] = None

stepxmlclient/rest_client/models/classification.py

@@ -0,0 +1,57 @@
+"""Classification-related data models for STEP REST API v2."""
+
+from typing import Any, Dict, List, Optional
+
+from pydantic import BaseModel, Field
+
+
+class ClassificationResponse(BaseModel):
+    """Response from classification GET/POST operation."""
+
+    id: str = Field(..., description="Classification ID")
+    objectType: str | None = Field(None, description="Classification object type ID")
+    name: str | None = Field(None, description="Classification name")
+    parent: str | None = Field(None, description="Parent classification ID")
+    values: Optional[Dict[str, Any]] = Field(None, description="Attribute values")
+    references: Optional[Dict[str, Any]] = Field(None, description="References")
+    attributeLinks: Optional[Dict[str, Any]] = Field(None, description="Attribute links")
+    dataContainers: Optional[Dict[str, Any]] = Field(None, description="Data containers")
+
+
+class ClassificationListResponse(BaseModel):
+    """Response from classification list/search operations."""
+
+    items: List[ClassificationResponse] = Field(default_factory=list, description="List of classifications")
+    total: Optional[int] = Field(None, description="Total number of classifications")
+    limit: Optional[int] = Field(None, description="Result limit")
+    offset: Optional[int] = Field(None, description="Result offset")
+    hasMore: Optional[bool] = Field(None, description="Whether more results available")
+
+
+class ClassificationCreateRequest(BaseModel):
+    """Request model for classification creation (POST /classifications).
+
+    Object type and a parent classification must be specified. An 'id' must not be supplied.
+    An auto ID pattern must be configured for the object type.
+    """
+
+    objectType: str = Field(..., description="Classification object type ID (required)")
+    parent: str = Field(..., description="Parent classification ID (required)")
+    name: str | None = Field(None, description="Classification name")
+    values: Optional[Dict[str, Any]] = Field(None, description="Attribute values")
+    references: Optional[Dict[str, Any]] = Field(None, description="References")
+    attributeLinks: Optional[Dict[str, Any]] = Field(None, description="Attribute links")
+    dataContainers: Optional[Dict[str, Any]] = Field(None, description="Data containers")
+
+
+class ClassificationUpdateRequest(BaseModel):
+    """Request model for classification updates (PATCH /classifications/{id})."""
+
+    name: str | None = Field(None, description="Updated classification name")
+    parent: str | None = Field(None, description="Updated parent classification ID")
+    values: Optional[Dict[str, Any]] = Field(None, description="Updated attribute values")
+    references: Optional[Dict[str, Any]] = Field(None, description="Updated references")
+    attributeLinks: Optional[Dict[str, Any]] = Field(None, description="Updated attribute links")
+    dataContainers: Optional[Dict[str, Any]] = Field(None, description="Updated data containers")
+
+

stepxmlclient/rest_client/models/collection.py

@@ -0,0 +1,26 @@
+"""Collection and collection group models for STEP REST API v2."""
+
+from typing import Any, Optional
+
+from pydantic import BaseModel, ConfigDict
+
+
+class CollectionResponse(BaseModel):
+    """STEP collection representation."""
+    model_config = ConfigDict(extra="allow")
+
+    id: str
+    name: str | None = None
+    parent: str | None = None
+    values: Optional[dict[str, Any]] = None
+    content: Optional[list[dict[str, Any]]] = None
+
+
+class CollectionGroupResponse(BaseModel):
+    """STEP collection group representation."""
+    model_config = ConfigDict(extra="allow")
+
+    id: str
+    name: str | None = None
+    parent: str | None = None
+    values: Optional[dict[str, Any]] = None