stepxmlclient 1.0.0__py3-none-any.whl

stepxmlclient/rest_client/operations/collections.py

@@ -0,0 +1,67 @@
+"""Collection operations for STEP REST API v2."""
+
+from typing import Any
+
+from ..base import BaseOperation, handle_rest_errors
+from ..exceptions import NotFoundError, ValidationError
+from ..models.collection import CollectionResponse
+
+
+class CollectionOperations(BaseOperation):
+    """Operations for STEP Collections."""
+    def __init__(self, client, logger=None, context=None, workspace=None):
+        super().__init__(client, operation_name="CollectionOperations", logger=logger, context=context, workspace=workspace)
+
+    @handle_rest_errors
+    def create_collection(self, data: dict[str, Any]) -> CollectionResponse:
+        self._log_operation("createCollection", data)
+        try:
+            r = self.client.createCollection(json=data, **self._build_context_params())
+        except Exception as e:
+            if "409" in str(e): raise ValidationError(str(e))
+            raise
+        return CollectionResponse(**r) if isinstance(r, dict) else r
+
+    @handle_rest_errors
+    def get_collection(self, collection_id: str) -> CollectionResponse:
+        self._validate_required_params({"collection_id": collection_id}, ["collection_id"])
+        self._log_operation("getCollection", {"id": collection_id})
+        try:
+            r = self.client.getCollection(id=collection_id, **self._build_context_params())
+        except Exception as e:
+            if "404" in str(e): raise NotFoundError(collection_id, "Collection")
+            raise
+        return CollectionResponse(**r) if isinstance(r, dict) else r
+
+    @handle_rest_errors
+    def create_or_replace_collection(self, collection_id: str, data: dict[str, Any]) -> CollectionResponse:
+        self._validate_required_params({"collection_id": collection_id}, ["collection_id"])
+        self._log_operation("createOrReplaceCollection", {"id": collection_id})
+        try:
+            r = self.client.createOrReplaceCollection(id=collection_id, json=data, **self._build_context_params())
+        except Exception as e:
+            if "400" in str(e): raise ValidationError(str(e))
+            raise
+        return CollectionResponse(**r) if isinstance(r, dict) else r
+
+    @handle_rest_errors
+    def delete_collection(self, collection_id: str) -> bool:
+        self._validate_required_params({"collection_id": collection_id}, ["collection_id"])
+        self._log_operation("deleteCollection", {"id": collection_id})
+        try:
+            self.client.deleteCollection(id=collection_id, **self._build_context_params())
+            return True
+        except Exception as e:
+            if "404" in str(e): raise NotFoundError(collection_id, "Collection")
+            raise
+
+    @handle_rest_errors
+    def get_collection_content(self, collection_id: str) -> CollectionResponse:
+        self._validate_required_params({"collection_id": collection_id}, ["collection_id"])
+        self._log_operation("getCollectionContent", {"id": collection_id})
+        try:
+            r = self.client.getCollectionContent(id=collection_id, **self._build_context_params())
+        except Exception as e:
+            if "404" in str(e): raise NotFoundError(collection_id, "Collection")
+            raise
+        return CollectionResponse(**r) if isinstance(r, dict) else r

stepxmlclient/rest_client/operations/contexts.py

@@ -0,0 +1,88 @@
+"""Context operations for STEP REST API v2.
+
+Covers the /contexts endpoints introduced in v1.4.0.
+"""
+
+import logging
+from typing import Any
+
+from ..base import BaseOperation, handle_rest_errors
+from ..exceptions import NotFoundError
+from ..models.context import ContextResponse
+
+
+class ContextOperations(BaseOperation):
+    """Operations for STEP Contexts."""
+
+    def __init__(self, client, logger: logging.Logger | None = None,
+                 context: str | None = None, workspace: str | None = None):
+        super().__init__(client, operation_name="ContextOperations", logger=logger,
+                         context=context, workspace=workspace)
+
+    @staticmethod
+    def _coerce_context_items(payload: Any) -> list[ContextResponse]:
+        """Normalize context list payloads from various response shapes."""
+        if payload is None:
+            return []
+
+        if isinstance(payload, list):
+            return [ContextResponse(**c) if isinstance(c, dict) else c for c in payload]
+
+        if isinstance(payload, dict):
+            for key in ("items", "data", "results", "contexts"):
+                items = payload.get(key)
+                if isinstance(items, list):
+                    return [ContextResponse(**c) if isinstance(c, dict) else c for c in items]
+            if "id" in payload:
+                return [ContextResponse(**payload)]
+            return []
+
+        if hasattr(payload, "json"):
+            try:
+                parsed = payload.json()
+            except Exception:  # noqa: BLE001
+                parsed = None
+            if parsed is not None:
+                return ContextOperations._coerce_context_items(parsed)
+
+        if hasattr(payload, "text"):
+            try:
+                import json
+                parsed = json.loads(payload.text)
+            except Exception:  # noqa: BLE001
+                parsed = None
+            if parsed is not None:
+                return ContextOperations._coerce_context_items(parsed)
+
+        return []
+
+    @handle_rest_errors
+    def get_contexts(self) -> list[ContextResponse]:
+        """List all available contexts.
+
+        Calls: GET /contexts -> getContexts
+
+        The spec declares the response as ``type: array`` of Context objects.
+        Some STEP servers / requests-openapi versions may wrap the array in a
+        dict, and some transports may return a ``requests.Response`` object.
+        We handle those shapes as well.
+        """
+        self._log_operation("getContexts", {})
+        response = self.client.getContexts(**self._build_context_params())
+        return self._coerce_context_items(response)
+
+    @handle_rest_errors
+    def get_context(self, context_id: str) -> ContextResponse:
+        """Get a specific context by ID.
+
+        Calls: GET /contexts/{id} -> getContext
+        """
+        self._validate_required_params({"context_id": context_id}, ["context_id"])
+        self._log_operation("getContext", {"id": context_id})
+        try:
+            response = self.client.getContext(id=context_id, **self._build_context_params())
+        except Exception as e:
+            if "404" in str(e):
+                raise NotFoundError(context_id, "Context")
+            raise
+        return ContextResponse(**response) if isinstance(response, dict) else response

stepxmlclient/rest_client/operations/data_type_groups.py

@@ -0,0 +1,68 @@
+"""Data type group operations for STEP REST API v2."""
+
+from typing import Any
+
+from ..base import BaseOperation, handle_rest_errors
+from ..exceptions import NotFoundError
+from ..models.data_type_group import DataTypeGroupResponse
+
+
+class DataTypeGroupOperations(BaseOperation):
+    """Operations for STEP Data Type Groups."""
+    def __init__(self, client, logger=None, context=None, workspace=None):
+        super().__init__(client, operation_name="DataTypeGroupOperations", logger=logger, context=context, workspace=workspace)
+
+    @handle_rest_errors
+    def get_data_type_group(self, group_id: str) -> DataTypeGroupResponse:
+        self._validate_required_params({"group_id": group_id}, ["group_id"])
+        self._log_operation("getDataTypeGroup", {"id": group_id})
+        try:
+            r = self.client.getDataTypeGroup(id=group_id, **self._build_context_params())
+        except Exception as e:
+            if "404" in str(e): raise NotFoundError(group_id, "DataTypeGroup")
+            raise
+        return DataTypeGroupResponse(**r) if isinstance(r, dict) else r
+
+    @handle_rest_errors
+    def get_data_type_group_children(self, group_id: str) -> list[str]:
+        self._validate_required_params({"group_id": group_id}, ["group_id"])
+        self._log_operation("getDataTypeGroupChildren", {"id": group_id})
+        try:
+            r = self.client.getDataTypeGroupChildren(id=group_id, **self._build_context_params())
+        except Exception as e:
+            if "404" in str(e): raise NotFoundError(group_id, "DataTypeGroup")
+            raise
+        return r if isinstance(r, list) else []
+
+    @handle_rest_errors
+    def get_data_type_group_attributes(self, group_id: str) -> list[dict[str, Any]]:
+        self._validate_required_params({"group_id": group_id}, ["group_id"])
+        self._log_operation("getDataTypeGroupAttributes", {"id": group_id})
+        try:
+            r = self.client.getDataTypeGroupAttributes(id=group_id, **self._build_context_params())
+        except Exception as e:
+            if "404" in str(e): raise NotFoundError(group_id, "DataTypeGroup")
+            raise
+        return r if isinstance(r, list) else []
+
+    @handle_rest_errors
+    def get_data_type_group_data_container_types(self, group_id: str) -> list[dict[str, Any]]:
+        self._validate_required_params({"group_id": group_id}, ["group_id"])
+        self._log_operation("getDataTypeGroupDataContainerTypes", {"id": group_id})
+        try:
+            r = self.client.getDataTypeGroupDataContainerTypes(id=group_id, **self._build_context_params())
+        except Exception as e:
+            if "404" in str(e): raise NotFoundError(group_id, "DataTypeGroup")
+            raise
+        return r if isinstance(r, list) else []
+
+    @handle_rest_errors
+    def get_data_type_group_reference_types(self, group_id: str) -> list[dict[str, Any]]:
+        self._validate_required_params({"group_id": group_id}, ["group_id"])
+        self._log_operation("getDataTypeGroupReferenceTypes", {"id": group_id})
+        try:
+            r = self.client.getDataTypeGroupReferenceTypes(id=group_id, **self._build_context_params())
+        except Exception as e:
+            if "404" in str(e): raise NotFoundError(group_id, "DataTypeGroup")
+            raise
+        return r if isinstance(r, list) else []

stepxmlclient/rest_client/operations/entities.py

@@ -0,0 +1,295 @@
+"""Entity operations for STEP REST API v2."""
+
+import logging
+from typing import Any, Optional
+
+from ..base import BaseOperation, handle_rest_errors
+from ..exceptions import NotFoundError, ValidationError
+from ..models.entity import (
+    EntityListResponse,
+    EntityResponse,
+)
+
+
+class EntityOperations(BaseOperation):
+    """Operations for STEP Entities."""
+    
+    def __init__(self, client, logger: Optional[logging.Logger] = None,
+                 context: str | None = None, workspace: str | None = None):
+        """Initialize entity operations.
+        
+        Args:
+            client: The REST API client
+            logger: Optional logger instance
+            context: STEP context ID for all API calls
+            workspace: STEP workspace ID (defaults to "Main" server-side)
+        """
+        super().__init__(client, operation_name="EntityOperations", logger=logger,
+                         context=context, workspace=workspace)
+    
+    @handle_rest_errors
+    def get_entity(self, entity_id: str,
+                   key_id: str | None = None,
+                   include_inherited_data: bool = False) -> EntityResponse:
+        """Get a single entity by ID.
+        
+        Args:
+            entity_id: The entity ID (or alternate key value if key_id is set)
+            key_id: Alternate key ID to use for lookup (optional)
+            include_inherited_data: Whether to include inherited attribute values (default: False)
+            
+        Returns:
+            EntityResponse with entity data
+            
+        Raises:
+            ValidationError: If entity_id is missing
+            NotFoundError: If entity not found
+            RestApiError: For other API errors
+        """
+        self._validate_required_params(
+            {"entity_id": entity_id},
+            ["entity_id"]
+        )
+        
+        query_params = self._build_context_params()
+        if key_id:
+            query_params["keyId"] = key_id
+        if include_inherited_data:
+            query_params["includeInheritedData"] = include_inherited_data
+        self._log_operation("getEntity", {"entity_id": entity_id})
+        
+        try:
+            response = self.client.getEntity(id=entity_id, **query_params)
+        except Exception as e:
+            if "404" in str(e):
+                raise NotFoundError(entity_id, "Entity")
+            raise
+        
+        if isinstance(response, dict):
+            return EntityResponse(**response)
+        return response
+    
+    @handle_rest_errors
+    def search_entities(self, condition: dict) -> EntityListResponse:
+        """Search entities using a STEP condition query.
+        
+        Args:
+            condition: A STEP condition object defining the search criteria.
+                       Supported conditionTypes: 'and', 'or', 'id', 'name',
+                       'textvalue', 'numericvalue', 'objecttype', 'simplebelow',
+                       'lovvalue', 'hasreferenceto', 'hasdatacontainerobject'.
+            
+        Returns:
+            EntityListResponse with matching entities
+            
+        Raises:
+            ValidationError: If condition is invalid
+            RestApiError: For API errors
+        """
+        self._validate_required_params({"condition": condition}, ["condition"])
+        body = {"condition": condition}
+        self._log_operation("createEntitySearch", {"condition": condition})
+        
+        response = self.client.createEntitySearch(json=body, **self._build_context_params())
+        
+        if isinstance(response, dict):
+            return EntityListResponse(**response)
+        return response
+    
+    def search_by_type(self, entity_type: str,
+                       limit: int = 20, offset: int = 0) -> EntityListResponse:
+        """Convenience method to search entities by type.
+        
+        Args:
+            entity_type: The entity type to filter by
+            limit: Result limit
+            offset: Result offset
+            
+        Returns:
+            EntityListResponse filtered by type
+        """
+        return self.search_entities(
+            condition={"conditionType": "objecttype", "objectType": entity_type}
+        )
+    
+
+    @handle_rest_errors
+    def find_similar_entities(self, entity_id: str,
+                              key_id: str | None = None) -> dict[str, Any]:
+        self._validate_required_params({"entity_id": entity_id}, ["entity_id"])
+        qp = self._build_context_params()
+        if key_id: qp["keyId"] = key_id
+        self._log_operation("findSimilarEntities", {"id": entity_id})
+        try:
+            r = self.client.findSimilarEntities(id=entity_id, **qp)
+        except Exception as e:
+            if "404" in str(e): raise NotFoundError(entity_id, "Entity")
+            raise
+        return r if isinstance(r, dict) else r
+
+    @handle_rest_errors
+    def entity_match_and_merge(self, data: dict[str, Any]) -> dict[str, Any]:
+        self._validate_required_params({"data": data}, ["data"])
+        self._log_operation("entityMatchAndMerge", data)
+        try:
+            r = self.client.entityMatchAndMerge(json=data, **self._build_context_params())
+        except Exception as e:
+            if "400" in str(e): raise ValidationError(str(e))
+            raise
+        return r if isinstance(r, dict) else r
+
+    @handle_rest_errors
+    def get_entity_approval_status(self, entity_id: str,
+                                   key_id: str | None = None) -> dict[str, Any]:
+        self._validate_required_params({"entity_id": entity_id}, ["entity_id"])
+        qp = self._build_context_params()
+        if key_id: qp["keyId"] = key_id
+        self._log_operation("getEntityApprovalStatus", {"id": entity_id})
+        try:
+            r = self.client.getEntityApprovalStatus(id=entity_id, **qp)
+        except Exception as e:
+            if "404" in str(e): raise NotFoundError(entity_id, "Entity")
+            raise
+        return r if isinstance(r, dict) else r
+
+    @handle_rest_errors
+    def approve_entity(self, entity_id: str,
+                       key_id: str | None = None) -> dict[str, Any]:
+        self._validate_required_params({"entity_id": entity_id}, ["entity_id"])
+        qp = self._build_context_params()
+        if key_id: qp["keyId"] = key_id
+        self._log_operation("approveEntity", {"id": entity_id})
+        try:
+            r = self.client.approveEntity(id=entity_id, **qp)
+        except Exception as e:
+            if "404" in str(e): raise NotFoundError(entity_id, "Entity")
+            raise
+        return r if isinstance(r, dict) else r
+
+    @handle_rest_errors
+    def approve_entity_deletion(self, entity_id: str,
+                                key_id: str | None = None) -> dict[str, Any]:
+        self._validate_required_params({"entity_id": entity_id}, ["entity_id"])
+        qp = self._build_context_params()
+        if key_id: qp["keyId"] = key_id
+        self._log_operation("approveEntityDeletion", {"id": entity_id})
+        try:
+            r = self.client.approveEntityDeletion(id=entity_id, **qp)
+        except Exception as e:
+            if "404" in str(e): raise NotFoundError(entity_id, "Entity")
+            raise
+        return r if isinstance(r, dict) else r
+
+    @handle_rest_errors
+    def purge_entity(self, entity_id: str,
+                     key_id: str | None = None) -> dict[str, Any]:
+        self._validate_required_params({"entity_id": entity_id}, ["entity_id"])
+        qp = self._build_context_params()
+        if key_id: qp["keyId"] = key_id
+        self._log_operation("purgeEntity", {"id": entity_id})
+        try:
+            r = self.client.purgeEntity(id=entity_id, **qp)
+        except Exception as e:
+            if "404" in str(e): raise NotFoundError(entity_id, "Entity")
+            raise
+        return r if isinstance(r, dict) else r
+
+    @handle_rest_errors
+    def get_entity_children(self, entity_id: str,
+                            key_id: str | None = None) -> list[str]:
+        self._validate_required_params({"entity_id": entity_id}, ["entity_id"])
+        qp = self._build_context_params()
+        if key_id: qp["keyId"] = key_id
+        self._log_operation("getEntityChildren", {"id": entity_id})
+        try:
+            r = self.client.getEntityChildren(id=entity_id, **qp)
+        except Exception as e:
+            if "404" in str(e): raise NotFoundError(entity_id, "Entity")
+            raise
+        return r if isinstance(r, list) else []
+
+    @handle_rest_errors
+    def get_entity_data_containers(self, entity_id: str,
+                                   key_id: str | None = None) -> dict[str, Any]:
+        self._validate_required_params({"entity_id": entity_id}, ["entity_id"])
+        qp = self._build_context_params()
+        if key_id: qp["keyId"] = key_id
+        self._log_operation("getEntityDataContainers", {"id": entity_id})
+        try:
+            r = self.client.getEntityDataContainers(id=entity_id, **qp)
+        except Exception as e:
+            if "404" in str(e): raise NotFoundError(entity_id, "Entity")
+            raise
+        return r if isinstance(r, dict) else r
+
+    @handle_rest_errors
+    def get_entity_incoming_references(self, entity_id: str,
+                                       key_id: str | None = None) -> dict[str, Any]:
+        self._validate_required_params({"entity_id": entity_id}, ["entity_id"])
+        qp = self._build_context_params()
+        if key_id: qp["keyId"] = key_id
+        self._log_operation("getEntityIncomingReferences", {"id": entity_id})
+        try:
+            r = self.client.getEntityIncomingReferences(id=entity_id, **qp)
+        except Exception as e:
+            if "404" in str(e): raise NotFoundError(entity_id, "Entity")
+            raise
+        return r if isinstance(r, dict) else r
+
+    @handle_rest_errors
+    def get_entity_value(self, entity_id: str, attribute_id: str,
+                         key_id: str | None = None) -> dict[str, Any]:
+        self._validate_required_params(
+            {"entity_id": entity_id, "attribute_id": attribute_id},
+            ["entity_id", "attribute_id"])
+        qp = self._build_context_params()
+        if key_id: qp["keyId"] = key_id
+        self._log_operation("getEntityValueByAttributeId",
+                           {"id": entity_id, "attributeId": attribute_id})
+        try:
+            r = self.client.getEntityValueByAttributeId(
+                id=entity_id, attributeId=attribute_id, **qp)
+        except Exception as e:
+            if "404" in str(e): raise NotFoundError(entity_id, "Entity")
+            raise
+        return r if isinstance(r, dict) else r
+
+    @handle_rest_errors
+    def replace_entity_value(self, entity_id: str, attribute_id: str,
+                             value: dict[str, Any],
+                             key_id: str | None = None) -> dict[str, Any]:
+        self._validate_required_params(
+            {"entity_id": entity_id, "attribute_id": attribute_id},
+            ["entity_id", "attribute_id"])
+        qp = self._build_context_params()
+        if key_id: qp["keyId"] = key_id
+        self._log_operation("replaceEntityValueByAttributeId",
+                           {"id": entity_id, "attributeId": attribute_id})
+        try:
+            r = self.client.replaceEntityValueByAttributeId(
+                id=entity_id, attributeId=attribute_id, json=value, **qp)
+        except Exception as e:
+            if "404" in str(e): raise NotFoundError(entity_id, "Entity")
+            if "400" in str(e): raise ValidationError(str(e))
+            raise
+        return r if isinstance(r, dict) else r
+
+    @handle_rest_errors
+    def delete_entity_value(self, entity_id: str, attribute_id: str,
+                            key_id: str | None = None) -> bool:
+        self._validate_required_params(
+            {"entity_id": entity_id, "attribute_id": attribute_id},
+            ["entity_id", "attribute_id"])
+        qp = self._build_context_params()
+        if key_id: qp["keyId"] = key_id
+        self._log_operation("deleteEntityValueByAttributeId",
+                           {"id": entity_id, "attributeId": attribute_id})
+        try:
+            self.client.deleteEntityValueByAttributeId(
+                id=entity_id, attributeId=attribute_id, **qp)
+            return True
+        except Exception as e:
+            if "404" in str(e): raise NotFoundError(entity_id, "Entity")
+            raise
+
+

stepxmlclient/rest_client/operations/event_processors.py

@@ -0,0 +1,109 @@
+"""Event processor operations for STEP REST API v2."""
+
+from typing import Any
+
+from ..base import BaseOperation, handle_rest_errors
+from ..exceptions import NotFoundError
+from ..models.event_processor import EventProcessorResponse
+
+
+class EventProcessorOperations(BaseOperation):
+    def __init__(self, client, logger=None, context=None, workspace=None):
+        super().__init__(client, operation_name="EventProcessorOperations", logger=logger, context=context, workspace=workspace)
+
+    @handle_rest_errors
+    def get_event_processors(self) -> list[dict[str, Any]]:
+        self._log_operation("getEventProcessors", {})
+        r = self.client.getEventProcessors(**self._build_context_params())
+        return r if isinstance(r, list) else []
+
+    @handle_rest_errors
+    def get_event_processor(self, ep_id: str) -> EventProcessorResponse:
+        self._validate_required_params({"ep_id": ep_id}, ["ep_id"])
+        self._log_operation("getEventProcessor", {"id": ep_id})
+        try:
+            r = self.client.getEventProcessor(id=ep_id, **self._build_context_params())
+        except Exception as e:
+            if "404" in str(e): raise NotFoundError(ep_id, "EventProcessor")
+            raise
+        return EventProcessorResponse(**r) if isinstance(r, dict) else r
+
+    @handle_rest_errors
+    def get_event_processor_status(self, ep_id: str) -> EventProcessorResponse:
+        self._validate_required_params({"ep_id": ep_id}, ["ep_id"])
+        self._log_operation("getEventProcessorStatus", {"id": ep_id})
+        try:
+            r = self.client.getEventProcessorStatus(id=ep_id, **self._build_context_params())
+        except Exception as e:
+            if "404" in str(e): raise NotFoundError(ep_id, "EventProcessor")
+            raise
+        return EventProcessorResponse(**r) if isinstance(r, dict) else r
+
+    @handle_rest_errors
+    def get_event_processor_execution_report(self, ep_id: str) -> list[dict[str, Any]]:
+        self._validate_required_params({"ep_id": ep_id}, ["ep_id"])
+        self._log_operation("getEventProcessorExecutionReport", {"id": ep_id})
+        try:
+            r = self.client.getEventProcessorExecutionReport(id=ep_id, **self._build_context_params())
+        except Exception as e:
+            if "404" in str(e): raise NotFoundError(ep_id, "EventProcessor")
+            raise
+        return r if isinstance(r, list) else []
+
+    @handle_rest_errors
+    def enable_event_processor(self, ep_id: str) -> EventProcessorResponse:
+        self._validate_required_params({"ep_id": ep_id}, ["ep_id"])
+        self._log_operation("enableEventProcessor", {"id": ep_id})
+        r = self.client.enableEventProcessor(id=ep_id, **self._build_context_params())
+        return EventProcessorResponse(**r) if isinstance(r, dict) else r
+
+    @handle_rest_errors
+    def disable_event_processor(self, ep_id: str) -> EventProcessorResponse:
+        self._validate_required_params({"ep_id": ep_id}, ["ep_id"])
+        self._log_operation("disableEventProcessor", {"id": ep_id})
+        r = self.client.disableEventProcessor(id=ep_id, **self._build_context_params())
+        return EventProcessorResponse(**r) if isinstance(r, dict) else r
+
+    @handle_rest_errors
+    def invoke_event_processor(self, ep_id: str, data: dict[str, Any] | None = None) -> EventProcessorResponse:
+        self._validate_required_params({"ep_id": ep_id}, ["ep_id"])
+        self._log_operation("invokeEventProcessor", {"id": ep_id})
+        kwargs = {"id": ep_id, **self._build_context_params()}
+        if data: kwargs["json"] = data
+        r = self.client.invokeEventProcessor(**kwargs)
+        return EventProcessorResponse(**r) if isinstance(r, dict) else r
+
+    @handle_rest_errors
+    def get_event_queue_status(self, ep_id: str) -> EventProcessorResponse:
+        self._validate_required_params({"ep_id": ep_id}, ["ep_id"])
+        self._log_operation("getEventProcessorEventQueueStatus", {"id": ep_id})
+        r = self.client.getEventProcessorEventQueueStatus(id=ep_id, **self._build_context_params())
+        return EventProcessorResponse(**r) if isinstance(r, dict) else r
+
+    @handle_rest_errors
+    def get_event_queue_unread_count(self, ep_id: str) -> EventProcessorResponse:
+        self._validate_required_params({"ep_id": ep_id}, ["ep_id"])
+        self._log_operation("getEventProcessorNumberOfUnreadEventsInEventQueue", {"id": ep_id})
+        r = self.client.getEventProcessorNumberOfUnreadEventsInEventQueue(id=ep_id, **self._build_context_params())
+        return EventProcessorResponse(**r) if isinstance(r, dict) else r
+
+    @handle_rest_errors
+    def enable_event_queue(self, ep_id: str) -> EventProcessorResponse:
+        self._validate_required_params({"ep_id": ep_id}, ["ep_id"])
+        self._log_operation("enableEventQueue", {"id": ep_id})
+        r = self.client.enableEventQueue(id=ep_id, **self._build_context_params())
+        return EventProcessorResponse(**r) if isinstance(r, dict) else r
+
+    @handle_rest_errors
+    def disable_event_queue(self, ep_id: str) -> EventProcessorResponse:
+        self._validate_required_params({"ep_id": ep_id}, ["ep_id"])
+        self._log_operation("disableEventQueue", {"id": ep_id})
+        r = self.client.disableEventQueue(id=ep_id, **self._build_context_params())
+        return EventProcessorResponse(**r) if isinstance(r, dict) else r
+
+    @handle_rest_errors
+    def get_event_processor_statistics(self, ep_id: str) -> EventProcessorResponse:
+        self._validate_required_params({"ep_id": ep_id}, ["ep_id"])
+        self._log_operation("getEventProcessorStatistics", {"id": ep_id})
+        r = self.client.getEventProcessorStatistics(id=ep_id, **self._build_context_params())
+        return EventProcessorResponse(**r) if isinstance(r, dict) else r