stepxmlclient 1.0.0__py3-none-any.whl

stepxmlclient/rest_client/models/common.py

@@ -0,0 +1,192 @@
+"""Common REST API models and utilities.
+
+Provides shared Pydantic models for pagination, error responses, and generic
+API response envelopes used across all REST operations.
+"""
+
+from typing import Any, Dict, Generic, List, Optional, TypeVar
+
+from pydantic import BaseModel, ConfigDict, Field, computed_field
+
+T = TypeVar('T')
+
+
+class PageInfo(BaseModel):
+    """Pagination metadata for paginated responses.
+    
+    Attributes:
+        offset: Current offset in result set
+        limit: Number of results per page
+        total: Total number of items available (if known)
+        has_more: Whether more results are available (computed)
+    """
+    
+    model_config = ConfigDict(
+        json_schema_extra={
+            "example": {
+                "offset": 0,
+                "limit": 20,
+                "total": 150,
+                "has_more": True
+            }
+        }
+    )
+    
+    offset: int = Field(0, ge=0, description="Current offset in result set")
+    limit: int = Field(20, ge=1, le=1000, description="Number of results per page")
+    total: Optional[int] = Field(None, ge=0, description="Total number of items available")
+    
+    @computed_field
+    @property
+    def has_more(self) -> bool:
+        """Calculate if more results are available."""
+        if self.total is None:
+            return False
+        return (self.offset + self.limit) < self.total
+
+
+class PagedResponse(BaseModel, Generic[T]):
+    """Generic paginated response wrapper.
+    
+    Wraps list results with pagination metadata.
+    
+    Attributes:
+        items: List of items in this page
+        pagination: Pagination metadata
+    """
+    
+    model_config = ConfigDict(
+        json_schema_extra={
+            "example": {
+                "items": [],
+                "pagination": {
+                    "offset": 0,
+                    "limit": 20,
+                    "total": 100,
+                    "has_more": True
+                }
+            }
+        }
+    )
+    
+    items: List[T] = Field(default_factory=list, description="Items in this page")
+    pagination: Optional[PageInfo] = Field(None, description="Pagination metadata")
+
+
+class ErrorDetail(BaseModel):
+    """Individual error detail in an error response.
+    
+    Attributes:
+        code: Machine-readable error code
+        message: Human-readable error message
+        field: Field name if error is field-specific
+        details: Additional context-specific details
+    """
+    
+    code: str = Field(..., description="Machine-readable error code")
+    message: str = Field(..., description="Human-readable error message")
+    field: str | None = Field(None, description="Field name if field-specific")
+    details: Optional[Dict[str, Any]] = Field(None, description="Additional details")
+
+
+class ErrorResponse(BaseModel):
+    """Standard API error response.
+    
+    Attributes:
+        error_code: Primary error code
+        error_message: Primary error message
+        status: HTTP status code
+        timestamp: ISO 8601 timestamp of error occurrence
+        request_id: Unique request identifier for debugging
+        error_details: List of detailed error information
+    """
+    
+    model_config = ConfigDict(
+        json_schema_extra={
+            "example": {
+                "error_code": "VALIDATION_ERROR",
+                "error_message": "Request validation failed",
+                "status": 400,
+                "timestamp": "2024-02-04T10:30:00Z",
+                "request_id": "req-12345",
+                "error_details": [
+                    {
+                        "code": "REQUIRED_FIELD",
+                        "message": "Field 'name' is required",
+                        "field": "name"
+                    }
+                ]
+            }
+        }
+    )
+    
+    error_code: str = Field(..., description="Primary error code")
+    error_message: str = Field(..., description="Primary error message")
+    status: int = Field(..., ge=400, le=599, description="HTTP status code")
+    timestamp: str | None = Field(None, description="ISO 8601 timestamp")
+    request_id: str | None = Field(None, description="Unique request identifier")
+    error_details: Optional[List[ErrorDetail]] = Field(None, description="Detailed error info")
+
+
+class ApiResponse(BaseModel, Generic[T]):
+    """Generic API response envelope.
+    
+    Standard wrapper for single-item API responses.
+    
+    Attributes:
+        data: Response data of generic type T
+        metadata: Optional metadata about the response
+        success: Whether the operation was successful
+        timestamp: ISO 8601 timestamp of response
+    """
+    model_config = ConfigDict(
+        json_schema_extra={
+            "example": {
+                "data": {},
+                "success": True,
+                "timestamp": "2024-02-04T10:30:00Z"
+            }
+        }
+    )
+    
+    data: Optional[T] = Field(None, description="Response data")
+    metadata: Optional[Dict[str, Any]] = Field(None, description="Response metadata")
+    success: bool = Field(True, description="Operation success flag")
+    timestamp: str | None = Field(None, description="ISO 8601 timestamp")
+
+
+class SearchFilter(BaseModel):
+    """Search filter specification.
+    
+    Attributes:
+        field: Field name to filter on
+        value: Filter value
+        operator: Comparison operator (eq, ne, gt, lt, contains, in, etc.)
+    """
+    
+    field: str = Field(..., description="Field name")
+    value: Any = Field(..., description="Filter value")
+    operator: str = Field("eq", description="Comparison operator")
+
+
+class SearchRequest(BaseModel):
+    """Generic search request.
+    
+    Attributes:
+        query: Free-text search query
+        filters: List of search filters
+        limit: Maximum results to return
+        offset: Offset for pagination
+        sort: Sort specification (field:asc|desc)
+    """
+    
+    query: str | None = Field(None, description="Free-text search query")
+    filters: Optional[List[SearchFilter]] = Field(None, description="Search filters")
+    limit: int = Field(20, ge=1, le=1000, description="Maximum results")
+    offset: int = Field(0, ge=0, description="Result offset")
+    sort: str | None = Field(None, description="Sort specification")
+
+
+# Type aliases for common response types
+SuccessResponse = ApiResponse[Dict[str, Any]]
+ListResponse = PagedResponse[Dict[str, Any]]

stepxmlclient/rest_client/models/context.py

@@ -0,0 +1,16 @@
+"""Context models for STEP REST API v2."""
+
+from typing import Any, Optional
+
+from pydantic import BaseModel, ConfigDict
+
+
+class ContextResponse(BaseModel):
+    """STEP context representation (Context / ContextDetails)."""
+    model_config = ConfigDict(extra="allow")
+
+    id: str
+    name: str | None = None
+    locale: str | None = None
+    dimension_points: Optional[list[str]] = None
+    values: Optional[dict[str, Any]] = None

stepxmlclient/rest_client/models/data_type_group.py

@@ -0,0 +1,15 @@
+"""Data type group model for STEP REST API v2."""
+
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict
+
+
+class DataTypeGroupResponse(BaseModel):
+    """STEP data type group representation."""
+    model_config = ConfigDict(extra="allow")
+
+    id: str
+    name: str | None = None
+    parent: str | None = None
+    values: dict[str, Any] | None = None

stepxmlclient/rest_client/models/entity.py

@@ -0,0 +1,63 @@
+"""Entity model classes for STEP REST API v2."""
+
+from typing import Any, Dict, List, Optional
+
+from pydantic import BaseModel, Field
+
+
+class EntityResponse(BaseModel):
+    """Response from entity GET/POST operation."""
+
+    id: str = Field(..., description="Entity ID")
+    objectType: str | None = Field(None, description="Entity object type ID")
+    name: str | None = Field(None, description="Entity name")
+    parent: str | None = Field(None, description="Parent entity 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 EntityListResponse(BaseModel):
+    """Response from entity list/search operations."""
+
+    items: List[EntityResponse] = Field(default_factory=list, description="List of entities")
+    total: Optional[int] = Field(None, description="Total number of entities")
+    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 EntityCreateRequest(BaseModel):
+    """Request model for entity creation (POST /entities).
+
+    Object type and a parent entity must be specified. An 'id' must not be supplied.
+    An auto ID pattern must be configured for the object type.
+    """
+
+    objectType: str = Field(..., description="Entity object type ID (required)")
+    parent: str = Field(..., description="Parent entity ID (required)")
+    name: str | None = Field(None, description="Entity 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 EntityUpdateRequest(BaseModel):
+    """Request model for entity updates (PATCH /entities/{id})."""
+
+    name: str | None = Field(None, description="Updated entity name")
+    parent: str | None = Field(None, description="Updated parent entity 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")
+
+
+class EntityRelationshipResponse(BaseModel):
+    """Response from entity references operations."""
+
+    id: str | None = Field(None, description="Entity ID")
+    references: Optional[Dict[str, Any]] = Field(None, description="References data")
+    total: Optional[int] = Field(None, description="Total number of references")

stepxmlclient/rest_client/models/event_processor.py

@@ -0,0 +1,15 @@
+"""Event processor models for STEP REST API v2."""
+
+from typing import Any, Optional
+
+from pydantic import BaseModel, ConfigDict
+
+
+class EventProcessorResponse(BaseModel):
+    """STEP event processor (summary/details)."""
+    model_config = ConfigDict(extra="allow")
+
+    id: str
+    name: str | None = None
+    user: str | None = None
+    values: Optional[dict[str, Any]] = None

stepxmlclient/rest_client/models/import_export.py

@@ -0,0 +1,43 @@
+"""Import/Export model classes for STEP REST API v2."""
+
+from typing import Any, Dict, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class ExportJobCreateRequest(BaseModel):
+    """Request to create an export job."""
+    
+    model_config = ConfigDict(json_schema_extra={
+        "example": {
+            "entityType": "Product",
+            "format": "XML",
+            "filters": {"status": "ACTIVE"},
+            "config": {"includeRelations": True}
+        }
+    })
+    
+    entityType: str = Field(..., description="Entity type to export (Product, Asset, Classification, Entity)")
+    format: str | None = Field("XML", description="Export format (XML, JSON, CSV)")
+    filters: Optional[Dict[str, Any]] = Field(None, description="Export filters")
+    config: Optional[Dict[str, Any]] = Field(None, description="Export configuration")
+
+
+class BackgroundProcessResponse(BaseModel):
+    """Response from export/import trigger operations.
+
+    Matches the STEP REST API v2 ``BackgroundProcessIdentification`` schema:
+    ``POST /export/{id}`` and ``POST /import/{id}`` both return only the
+    background-process ``id`` so the caller can poll for status.
+    """
+
+    model_config = ConfigDict(populate_by_name=True, json_schema_extra={
+        "example": {"id": "bg-process-0042"}
+    })
+
+    id: str | None = Field(None, description="Background process ID")
+
+
+# Backward-compatible alias so existing imports don't break immediately.
+ExportJobResponse = BackgroundProcessResponse
+

stepxmlclient/rest_client/models/integration_endpoint.py

@@ -0,0 +1,16 @@
+"""Integration endpoint models for STEP REST API v2."""
+
+from typing import Any, Optional
+
+from pydantic import BaseModel, ConfigDict
+
+
+class IntegrationEndpointResponse(BaseModel):
+    """STEP integration endpoint (summary/details) — Inbound, Outbound, Gateway."""
+    model_config = ConfigDict(extra="allow")
+
+    id: str
+    name: str | None = None
+    description: str | None = None
+    user: str | None = None
+    values: dict[str, Any] | None = None

stepxmlclient/rest_client/models/product.py

@@ -0,0 +1,200 @@
+"""Product-related REST API models.
+
+Provides Pydantic models aligned with STEP REST API v2 product schemas.
+"""
+
+from typing import Any, Dict, List, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class ProductResponse(BaseModel):
+    """Single product response data.
+
+    Mirrors the REST API Product schema:
+    - objectType/parent describe product placement and type
+    - values/references are dynamic maps keyed by ID
+    - attributeLinks/dataContainers are typed arrays/maps from API
+    """
+    
+    model_config = ConfigDict(
+        json_schema_extra={
+            "example": {
+                "id": "PROD123",
+                "name": "Example Product",
+                "objectType": "SalesItem",
+                "parent": "I-Level3-122",
+                "values": {
+                    "UPC": {
+                        "value": {
+                            "value": "445555555575"
+                        }
+                    }
+                },
+                "references": {
+                    "Accessory": {
+                        "references": [
+                            {
+                                "target": "I-SalesItem-1111"
+                            }
+                        ]
+                    }
+                },
+                "attributeLinks": [],
+                "dataContainers": {}
+            }
+        }
+    )
+
+    id: str = Field(..., description="Product ID")
+    name: str | None = Field(None, description="Product name/description")
+    objectType: str | None = Field(None, description="Object type ID")
+    parent: str | None = Field(None, description="Parent product ID")
+    values: Optional[Dict[str, Any]] = Field(None, description="Product values keyed by attribute ID")
+    references: Optional[Dict[str, Any]] = Field(None, description="References keyed by reference type ID")
+    attributeLinks: Optional[List[Dict[str, Any]]] = Field(None, description="Attribute links")
+    dataContainers: Optional[Dict[str, Any]] = Field(None, description="Data containers keyed by type ID")
+
+
+class ProductListResponse(BaseModel):
+    """Paginated product list response.
+    
+    Attributes:
+        items: List of ProductResponse objects
+        total: Total number of products
+        limit: Items per page
+        offset: Current offset
+        has_more: Whether more results are available
+    """
+    
+    model_config = ConfigDict(
+        json_schema_extra={
+            "example": {
+                "items": [],
+                "total": 150,
+                "limit": 20,
+                "offset": 0,
+                "has_more": True
+            }
+        }
+    )
+    
+    items: List[ProductResponse] = Field(default_factory=list, description="Products in this page")
+    total: Optional[int] = Field(None, ge=0, description="Total number of products")
+    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 ProductSearchRequest(BaseModel):
+    """Search request for products.
+    
+    Attributes:
+        query: Free-text search query
+        object_type: Filter by object type
+        modified_since: Only products modified after this date (ISO 8601)
+        limit: Max results to return
+        offset: Result offset for pagination
+        include_values: Whether to include product values
+        include_attributes: Whether to include attributes
+    """
+    
+    model_config = ConfigDict(
+        json_schema_extra={
+            "example": {
+                "query": "*",
+                "object_type": "SalesItem",
+                "limit": 20,
+                "offset": 0,
+                "include_values": True,
+                "include_attributes": True
+            }
+        }
+    )
+
+    query: str = Field("*", description="Free-text search query (default: all)")
+    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_values: bool = Field(True, description="Include product values")
+    include_attributes: bool = Field(True, description="Include product attributes")
+
+
+class ProductCreateRequest(BaseModel):
+    """Request to create a new product.
+    
+    Attributes:
+        objectType: Object type ID (required)
+        parent: Parent product ID (required)
+        name: Product name/description
+        values: Product values map keyed by attribute ID
+        references: Product references map keyed by reference/link type ID
+        attributeLinks: Product attribute links
+        dataContainers: Product data containers keyed by data container type ID
+    """
+    
+    model_config = ConfigDict(
+        json_schema_extra={
+            "example": {
+                "objectType": "SalesItem",
+                "parent": "I-Level3-122",
+                "name": "New Product",
+                "values": {
+                    "UPC": {
+                        "value": {
+                            "value": "445555555575"
+                        }
+                    }
+                },
+                "references": {},
+                "attributeLinks": [],
+                "dataContainers": {}
+            }
+        }
+    )
+
+    objectType: str = Field(..., description="Object type ID")
+    parent: str = Field(..., description="Parent product ID")
+    name: str | None = Field(None, description="Product name/description")
+    values: Optional[Dict[str, Any]] = Field(None, description="Product values")
+    references: Optional[Dict[str, Any]] = Field(None, description="Product references")
+    attributeLinks: Optional[List[Dict[str, Any]]] = Field(None, description="Product attribute links")
+    dataContainers: Optional[Dict[str, Any]] = Field(None, description="Product data containers")
+
+
+class ProductUpdateRequest(BaseModel):
+    """Request to update an existing product.
+    
+    Attributes:
+        name: Updated product name/description
+        parent: Optional new parent product ID
+        values: Updated product values
+        references: Updated references
+        attributeLinks: Updated attribute links
+        dataContainers: Updated data containers
+    """
+    
+    model_config = ConfigDict(
+        json_schema_extra={
+            "example": {
+                "name": "Updated Product Name",
+                "parent": "ElectricGuitars",
+                "values": {
+                    "Body": {
+                        "value": {
+                            "value": "Alder"
+                        }
+                    }
+                },
+                "references": {}
+            }
+        }
+    )
+
+    name: str | None = Field(None, description="Updated product name")
+    parent: str | None = Field(None, description="Updated parent product ID")
+    values: Optional[Dict[str, Any]] = Field(None, description="Values to update")
+    references: Optional[Dict[str, Any]] = Field(None, description="References to update")
+    attributeLinks: Optional[List[Dict[str, Any]]] = Field(None, description="Attribute links to update")
+    dataContainers: Optional[Dict[str, Any]] = Field(None, description="Data containers to update")