stepxmlclient 1.0.0__py3-none-any.whl

stepxmlclient/rest_client/operations/attributes.py

@@ -0,0 +1,252 @@
+"""Attribute and type-definition operations for STEP REST API v2.
+
+Covers Attributes, Lists of Values, Data Container Types, Data Type Groups,
+Object Types, Reference Types, Units, and Unique Keys per the OpenAPI spec.
+"""
+
+import logging
+from typing import Any, Optional
+
+from ..base import BaseOperation, handle_rest_errors
+from ..exceptions import NotFoundError
+from ..models.attribute import (
+    AttributeResponse,
+    ListOfValueResponse,
+)
+
+
+class AttributeOperations(BaseOperation):
+    """Operations for STEP Attributes and type definitions.
+
+    Note: The STEP REST API v2 (v1.4.0) only provides GET access for attribute
+    and type-definition resources. There is no create, update, or delete for
+    attributes via the REST API.
+    """
+
+    def __init__(self, client, logger: Optional[logging.Logger] = None,
+                 context: str | None = None, workspace: str | None = None):
+        super().__init__(client, operation_name="AttributeOperations", logger=logger,
+                         context=context, workspace=workspace)
+
+    # ------------------------------------------------------------------
+    # Attributes (tag: Attributes)
+    # ------------------------------------------------------------------
+
+    @handle_rest_errors
+    def get_attribute(self, attribute_id: str) -> AttributeResponse:
+        """Get a single attribute definition by ID.
+
+        Calls: GET /attributes/{id} → getAttribute
+
+        Args:
+            attribute_id: The attribute ID
+
+        Returns:
+            AttributeResponse with attribute definition
+
+        Raises:
+            ValidationError: If attribute_id is missing
+            NotFoundError: If attribute not found
+        """
+        self._validate_required_params(
+            {"attribute_id": attribute_id},
+            ["attribute_id"]
+        )
+        self._log_operation("getAttribute", {"id": attribute_id})
+
+        try:
+            response = self.client.getAttribute(id=attribute_id, **self._build_context_params())
+        except Exception as e:
+            if "404" in str(e):
+                raise NotFoundError(attribute_id, "Attribute")
+            raise
+
+        if isinstance(response, dict):
+            return AttributeResponse(**response)
+        return response
+
+    # ------------------------------------------------------------------
+    # Lists Of Values (tag: Lists Of Values)
+    # ------------------------------------------------------------------
+
+    @handle_rest_errors
+    def get_list_of_values(self, lov_id: str) -> ListOfValueResponse:
+        """Get a List of Values by ID.
+
+        Calls: GET /lists-of-values/{id} → getListOfValuess
+
+        Args:
+            lov_id: The LOV ID
+
+        Returns:
+            ListOfValueResponse with LOV data
+
+        Raises:
+            ValidationError: If lov_id is missing
+            NotFoundError: If LOV not found
+        """
+        self._validate_required_params(
+            {"lov_id": lov_id},
+            ["lov_id"]
+        )
+        self._log_operation("getListOfValuess", {"id": lov_id})
+
+        try:
+            response = self.client.getListOfValuess(id=lov_id, **self._build_context_params())
+        except Exception as e:
+            if "404" in str(e):
+                raise NotFoundError(lov_id, "ListOfValues")
+            raise
+
+        if isinstance(response, dict):
+            return ListOfValueResponse(**response)
+        return response
+
+    @handle_rest_errors
+    def get_list_of_values_entries(self, lov_id: str) -> list[dict[str, Any]]:
+        """Get the value entries for a List of Values.
+
+        Calls: GET /lists-of-values/{id}/value-entries → getListOfValuessEntries
+
+        Args:
+            lov_id: The LOV ID
+
+        Returns:
+            List of value entry dictionaries
+
+        Raises:
+            ValidationError: If lov_id is missing
+            NotFoundError: If LOV not found
+        """
+        self._validate_required_params(
+            {"lov_id": lov_id},
+            ["lov_id"]
+        )
+        self._log_operation("getListOfValuessEntries", {"id": lov_id})
+
+        try:
+            response = self.client.getListOfValuessEntries(id=lov_id, **self._build_context_params())
+        except Exception as e:
+            if "404" in str(e):
+                raise NotFoundError(lov_id, "ListOfValues")
+            raise
+
+        return self._coerce_list_payload(response)
+
+    # ------------------------------------------------------------------
+    # Type definitions (various tags — read-only single GET each)
+    # ------------------------------------------------------------------
+
+    @handle_rest_errors
+    def get_data_container_type(self, type_id: str) -> dict[str, Any]:
+        """Get a data container type definition by ID.
+
+        Calls: GET /data-container-types/{id} → getDataContainerType
+        """
+        self._validate_required_params({"type_id": type_id}, ["type_id"])
+        self._log_operation("getDataContainerType", {"id": type_id})
+        try:
+            response = self.client.getDataContainerType(id=type_id, **self._build_context_params())
+        except Exception as e:
+            if "404" in str(e):
+                raise NotFoundError(type_id, "DataContainerType")
+            raise
+        return response if isinstance(response, dict) else response
+
+    @handle_rest_errors
+    def get_data_type_group(self, group_id: str) -> dict[str, Any]:
+        """Get a data type group definition by ID.
+
+        Calls: GET /data-type-groups/{id} → getDataTypeGroup
+        """
+        self._validate_required_params({"group_id": group_id}, ["group_id"])
+        self._log_operation("getDataTypeGroup", {"id": group_id})
+        try:
+            response = 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 response if isinstance(response, dict) else response
+
+    @handle_rest_errors
+    def get_object_type(self, type_id: str) -> dict[str, Any]:
+        """Get an object type definition by ID.
+
+        Calls: GET /object-types/{id} → getObjectType
+        """
+        self._validate_required_params({"type_id": type_id}, ["type_id"])
+        self._log_operation("getObjectType", {"id": type_id})
+        try:
+            response = self.client.getObjectType(id=type_id, **self._build_context_params())
+        except Exception as e:
+            if "404" in str(e):
+                raise NotFoundError(type_id, "ObjectType")
+            raise
+        return response if isinstance(response, dict) else response
+
+    @handle_rest_errors
+    def get_object_type_children(self, type_id: str) -> list[str]:
+        """Get child object types for a given object type.
+
+        Calls: GET /object-types/{id}/children → getObjectTypeChildren
+        """
+        self._validate_required_params({"type_id": type_id}, ["type_id"])
+        self._log_operation("getObjectTypeChildren", {"id": type_id})
+        try:
+            response = self.client.getObjectTypeChildren(id=type_id, **self._build_context_params())
+        except Exception as e:
+            if "404" in str(e):
+                raise NotFoundError(type_id, "ObjectType")
+            raise
+        if isinstance(response, list):
+            return response
+        return []
+
+    @handle_rest_errors
+    def get_reference_type(self, reference_type_id: str) -> dict[str, Any]:
+        """Get a reference type definition by ID.
+
+        Calls: GET /reference-types/{id} → getReferenceType
+        """
+        self._validate_required_params({"reference_type_id": reference_type_id}, ["reference_type_id"])
+        self._log_operation("getReferenceType", {"id": reference_type_id})
+        try:
+            response = self.client.getReferenceType(id=reference_type_id, **self._build_context_params())
+        except Exception as e:
+            if "404" in str(e):
+                raise NotFoundError(reference_type_id, "ReferenceType")
+            raise
+        return response if isinstance(response, dict) else response
+
+    @handle_rest_errors
+    def get_unit(self, unit_id: str) -> dict[str, Any]:
+        """Get a unit definition by ID.
+
+        Calls: GET /units/{id} → getUnit
+        """
+        self._validate_required_params({"unit_id": unit_id}, ["unit_id"])
+        self._log_operation("getUnit", {"id": unit_id})
+        try:
+            response = self.client.getUnit(id=unit_id, **self._build_context_params())
+        except Exception as e:
+            if "404" in str(e):
+                raise NotFoundError(unit_id, "Unit")
+            raise
+        return response if isinstance(response, dict) else response
+
+    @handle_rest_errors
+    def get_unique_key(self, key_id: str) -> dict[str, Any]:
+        """Get a unique key definition by ID.
+
+        Calls: GET /unique-keys/{id} → getUniqueKey
+        """
+        self._validate_required_params({"key_id": key_id}, ["key_id"])
+        self._log_operation("getUniqueKey", {"id": key_id})
+        try:
+            response = self.client.getUniqueKey(id=key_id, **self._build_context_params())
+        except Exception as e:
+            if "404" in str(e):
+                raise NotFoundError(key_id, "UniqueKey")
+            raise
+        return response if isinstance(response, dict) else response

stepxmlclient/rest_client/operations/background_processes.py

@@ -0,0 +1,84 @@
+"""Background process operations for STEP REST API v2."""
+
+from typing import Any
+
+from ..base import BaseOperation, handle_rest_errors
+from ..exceptions import NotFoundError
+from ..models.background_process import BackgroundProcessResponse
+
+
+class BackgroundProcessOperations(BaseOperation):
+    def __init__(self, client, logger=None, context=None, workspace=None):
+        super().__init__(client, operation_name="BackgroundProcessOperations", logger=logger, context=context, workspace=workspace)
+
+    @handle_rest_errors
+    def get_background_process(self, process_id: str) -> BackgroundProcessResponse:
+        self._validate_required_params({"process_id": process_id}, ["process_id"])
+        self._log_operation("getBackgroundProcess", {"id": process_id})
+        try:
+            r = self.client.getBackgroundProcess(id=process_id, **self._build_context_params())
+        except Exception as e:
+            if "404" in str(e): raise NotFoundError(process_id, "BackgroundProcess")
+            raise
+        return BackgroundProcessResponse(**r) if isinstance(r, dict) else r
+
+    @handle_rest_errors
+    def get_execution_report(self, process_id: str) -> list[dict[str, Any]]:
+        self._validate_required_params({"process_id": process_id}, ["process_id"])
+        self._log_operation("getBackgroundProcessExecutionReport", {"id": process_id})
+        try:
+            r = self.client.getBackgroundProcessExecutionReport(id=process_id, **self._build_context_params())
+        except Exception as e:
+            if "404" in str(e): raise NotFoundError(process_id, "BackgroundProcess")
+            raise
+        return r if isinstance(r, list) else []
+
+    @handle_rest_errors
+    def get_attachments_metadata(self, process_id: str) -> list[dict[str, Any]]:
+        self._validate_required_params({"process_id": process_id}, ["process_id"])
+        self._log_operation("getBackgroundProcessAttachmentsMetadata", {"id": process_id})
+        try:
+            r = self.client.getBackgroundProcessAttachmentsMetadata(id=process_id, **self._build_context_params())
+        except Exception as e:
+            if "404" in str(e): raise NotFoundError(process_id, "BackgroundProcess")
+            raise
+        return r if isinstance(r, list) else []
+
+    @handle_rest_errors
+    def get_attachment_metadata(self, process_id: str, attachment_id: str) -> BackgroundProcessResponse:
+        self._validate_required_params({"process_id": process_id, "attachment_id": attachment_id}, ["process_id", "attachment_id"])
+        self._log_operation("getBackgroundProcessAttachmentMetadata", {"id": process_id, "attachmentId": attachment_id})
+        try:
+            r = self.client.getBackgroundProcessAttachmentMetadata(id=process_id, attachmentId=attachment_id, **self._build_context_params())
+        except Exception as e:
+            if "404" in str(e): raise NotFoundError(process_id, "BackgroundProcess")
+            raise
+        return BackgroundProcessResponse(**r) if isinstance(r, dict) else r
+
+    @handle_rest_errors
+    def get_attachment_content(self, process_id: str, attachment_id: str) -> bytes:
+        self._validate_required_params({"process_id": process_id, "attachment_id": attachment_id}, ["process_id", "attachment_id"])
+        self._log_operation("getBackgroundProcessAttachmentContent", {"id": process_id, "attachmentId": attachment_id})
+        try:
+            r = self.client.getBackgroundProcessAttachmentContent(id=process_id, attachmentId=attachment_id, **self._build_context_params())
+        except Exception as e:
+            if "404" in str(e): raise NotFoundError(process_id, "BackgroundProcess")
+            raise
+        return r
+
+    @handle_rest_errors
+    def get_process_types(self) -> list[dict[str, Any]]:
+        self._log_operation("getBackgroundProcessTypes", {})
+        r = self.client.getBackgroundProcessTypes(**self._build_context_params())
+        return r if isinstance(r, list) else []
+
+    @handle_rest_errors
+    def get_processes_of_type(self, type_id: str) -> list[dict[str, Any]]:
+        self._validate_required_params({"type_id": type_id}, ["type_id"])
+        self._log_operation("getBackgroundProcessesOfType", {"typeId": type_id})
+        try:
+            r = self.client.getBackgroundProcessesOfType(typeId=type_id, **self._build_context_params())
+        except Exception as e:
+            if "404" in str(e): raise NotFoundError(type_id, "BackgroundProcessType")
+            raise
+        return r if isinstance(r, list) else []

stepxmlclient/rest_client/operations/batch.py

@@ -0,0 +1,28 @@
+"""Batch operations for STEP REST API v2."""
+
+from typing import Any
+
+from ..base import BaseOperation, handle_rest_errors
+from ..exceptions import ValidationError
+from ..models.batch import BatchResponse
+
+
+class BatchOperations(BaseOperation):
+    """Operations for STEP Batch execution."""
+    def __init__(self, client, logger=None, context=None, workspace=None):
+        super().__init__(client, operation_name="BatchOperations", logger=logger, context=context, workspace=workspace)
+
+    @handle_rest_errors
+    def execute_batch_operation(self, data: dict[str, Any]) -> BatchResponse:
+        """Execute a batch of operations.
+
+        Calls: POST /batch/execute -> executeBatchOperation
+        """
+        self._validate_required_params({"data": data}, ["data"])
+        self._log_operation("executeBatchOperation", {})
+        try:
+            r = self.client.executeBatchOperation(json=data, **self._build_context_params())
+        except Exception as e:
+            if "400" in str(e): raise ValidationError(str(e))
+            raise
+        return BatchResponse(**r) if isinstance(r, dict) else r

stepxmlclient/rest_client/operations/classifications.py

@@ -0,0 +1,248 @@
+"""Classification 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.classification import ClassificationListResponse, ClassificationResponse
+
+
+class ClassificationOperations(BaseOperation):
+    """Operations for STEP Classifications."""
+    
+    def __init__(self, client, logger: Optional[logging.Logger] = None,
+                 context: str | None = None, workspace: str | None = None):
+        """Initialize classification 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="ClassificationOperations", logger=logger,
+                         context=context, workspace=workspace)
+    
+    @handle_rest_errors
+    def get_classification(self, classification_id: str,
+                          key_id: str | None = None,
+                          include_inherited_data: bool = False) -> ClassificationResponse:
+        """Get a single classification by ID.
+        
+        Args:
+            classification_id: The classification 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:
+            ClassificationResponse with classification data
+            
+        Raises:
+            ValidationError: If classification_id is missing
+            NotFoundError: If classification not found
+            RestApiError: For other API errors
+        """
+        self._validate_required_params(
+            {"classification_id": classification_id},
+            ["classification_id"]
+        )
+        
+        query_params: dict[str, Any] = 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("getClassification", {"classification_id": classification_id})
+        
+        try:
+            response = self.client.getClassification(id=classification_id, **query_params)
+        except Exception as e:
+            if "404" in str(e):
+                raise NotFoundError(classification_id, "Classification")
+            raise
+        
+        if isinstance(response, dict):
+            return ClassificationResponse(**response)
+        return response
+    
+    @handle_rest_errors
+    def search_classifications(self, condition: dict) -> ClassificationListResponse:
+        """Search classifications 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:
+            ClassificationListResponse with matching classifications
+            
+        Raises:
+            ValidationError: If condition is invalid
+            RestApiError: For API errors
+        """
+        self._validate_required_params({"condition": condition}, ["condition"])
+        body = {"condition": condition}
+        self._log_operation("createClassificationSearch", {"condition": condition})
+        
+        response = self.client.createClassificationSearch(json=body, **self._build_context_params())
+        
+        if isinstance(response, dict):
+            return ClassificationListResponse(**response)
+        return response
+    
+    def search_by_type(self, classification_type: str) -> ClassificationListResponse:
+        """Search classifications by object type (convenience method).
+        
+        Args:
+            classification_type: The object type ID to filter by
+            
+        Returns:
+            ClassificationListResponse filtered by type
+        """
+        return self.search_classifications(
+            condition={"conditionType": "objecttype", "objectType": classification_type}
+        )
+
+
+    @handle_rest_errors
+    def get_classification_approval_status(self, classification_id: str,
+                                           key_id: str | None = None) -> dict[str, Any]:
+        self._validate_required_params({"classification_id": classification_id}, ["classification_id"])
+        qp = self._build_context_params()
+        if key_id: qp["keyId"] = key_id
+        self._log_operation("getClassificationApprovalStatus", {"id": classification_id})
+        try:
+            r = self.client.getClassificationApprovalStatus(id=classification_id, **qp)
+        except Exception as e:
+            if "404" in str(e): raise NotFoundError(classification_id, "Classification")
+            raise
+        return r if isinstance(r, dict) else r
+
+    @handle_rest_errors
+    def approve_classification(self, classification_id: str,
+                               key_id: str | None = None) -> dict[str, Any]:
+        self._validate_required_params({"classification_id": classification_id}, ["classification_id"])
+        qp = self._build_context_params()
+        if key_id: qp["keyId"] = key_id
+        self._log_operation("approveClassification", {"id": classification_id})
+        try:
+            r = self.client.approveClassification(id=classification_id, **qp)
+        except Exception as e:
+            if "404" in str(e): raise NotFoundError(classification_id, "Classification")
+            raise
+        return r if isinstance(r, dict) else r
+
+    @handle_rest_errors
+    def approve_classification_deletion(self, classification_id: str,
+                                        key_id: str | None = None) -> dict[str, Any]:
+        self._validate_required_params({"classification_id": classification_id}, ["classification_id"])
+        qp = self._build_context_params()
+        if key_id: qp["keyId"] = key_id
+        self._log_operation("approveClassificationDeletion", {"id": classification_id})
+        try:
+            r = self.client.approveClassificationDeletion(id=classification_id, **qp)
+        except Exception as e:
+            if "404" in str(e): raise NotFoundError(classification_id, "Classification")
+            raise
+        return r if isinstance(r, dict) else r
+
+    @handle_rest_errors
+    def purge_classification(self, classification_id: str,
+                             key_id: str | None = None) -> dict[str, Any]:
+        self._validate_required_params({"classification_id": classification_id}, ["classification_id"])
+        qp = self._build_context_params()
+        if key_id: qp["keyId"] = key_id
+        self._log_operation("purgeClassification", {"id": classification_id})
+        try:
+            r = self.client.purgeClassification(id=classification_id, **qp)
+        except Exception as e:
+            if "404" in str(e): raise NotFoundError(classification_id, "Classification")
+            raise
+        return r if isinstance(r, dict) else r
+
+    @handle_rest_errors
+    def get_classification_assets(self, classification_id: str,
+                                  key_id: str | None = None) -> list[dict[str, Any]]:
+        self._validate_required_params({"classification_id": classification_id}, ["classification_id"])
+        qp = self._build_context_params()
+        if key_id: qp["keyId"] = key_id
+        self._log_operation("getClassificationAssets", {"id": classification_id})
+        try:
+            r = self.client.getClassificationAssets(id=classification_id, **qp)
+        except Exception as e:
+            if "404" in str(e): raise NotFoundError(classification_id, "Classification")
+            raise
+        return r if isinstance(r, list) else []
+
+    @handle_rest_errors
+    def get_classification_incoming_references(self, classification_id: str,
+                                               key_id: str | None = None) -> dict[str, Any]:
+        self._validate_required_params({"classification_id": classification_id}, ["classification_id"])
+        qp = self._build_context_params()
+        if key_id: qp["keyId"] = key_id
+        self._log_operation("getClassificationIncomingReferences", {"id": classification_id})
+        try:
+            r = self.client.getClassificationIncomingReferences(id=classification_id, **qp)
+        except Exception as e:
+            if "404" in str(e): raise NotFoundError(classification_id, "Classification")
+            raise
+        return r if isinstance(r, dict) else r
+
+    @handle_rest_errors
+    def get_classification_value(self, classification_id: str, attribute_id: str,
+                                 key_id: str | None = None) -> dict[str, Any]:
+        self._validate_required_params(
+            {"classification_id": classification_id, "attribute_id": attribute_id},
+            ["classification_id", "attribute_id"])
+        qp = self._build_context_params()
+        if key_id: qp["keyId"] = key_id
+        self._log_operation("getClassificationValueByAttributeId",
+                           {"id": classification_id, "attributeId": attribute_id})
+        try:
+            r = self.client.getClassificationValueByAttributeId(
+                id=classification_id, attributeId=attribute_id, **qp)
+        except Exception as e:
+            if "404" in str(e): raise NotFoundError(classification_id, "Classification")
+            raise
+        return r if isinstance(r, dict) else r
+
+    @handle_rest_errors
+    def replace_classification_value(self, classification_id: str, attribute_id: str,
+                                     value: dict[str, Any],
+                                     key_id: str | None = None) -> dict[str, Any]:
+        self._validate_required_params(
+            {"classification_id": classification_id, "attribute_id": attribute_id},
+            ["classification_id", "attribute_id"])
+        qp = self._build_context_params()
+        if key_id: qp["keyId"] = key_id
+        self._log_operation("replaceClassificationValueByAttributeId",
+                           {"id": classification_id, "attributeId": attribute_id})
+        try:
+            r = self.client.replaceClassificationValueByAttributeId(
+                id=classification_id, attributeId=attribute_id, json=value, **qp)
+        except Exception as e:
+            if "404" in str(e): raise NotFoundError(classification_id, "Classification")
+            if "400" in str(e): raise ValidationError(str(e))
+            raise
+        return r if isinstance(r, dict) else r
+
+    @handle_rest_errors
+    def delete_classification_value(self, classification_id: str, attribute_id: str,
+                                    key_id: str | None = None) -> bool:
+        self._validate_required_params(
+            {"classification_id": classification_id, "attribute_id": attribute_id},
+            ["classification_id", "attribute_id"])
+        qp = self._build_context_params()
+        if key_id: qp["keyId"] = key_id
+        self._log_operation("deleteClassificationValueByAttributeId",
+                           {"id": classification_id, "attributeId": attribute_id})
+        try:
+            self.client.deleteClassificationValueByAttributeId(
+                id=classification_id, attributeId=attribute_id, **qp)
+            return True
+        except Exception as e:
+            if "404" in str(e): raise NotFoundError(classification_id, "Classification")
+            raise

stepxmlclient/rest_client/operations/collection_groups.py

@@ -0,0 +1,46 @@
+"""Collection group operations for STEP REST API v2."""
+
+from typing import Any
+
+from ..base import BaseOperation, handle_rest_errors
+from ..exceptions import NotFoundError
+from ..models.collection import CollectionGroupResponse
+
+
+class CollectionGroupOperations(BaseOperation):
+    """Operations for STEP Collection Groups."""
+    def __init__(self, client, logger=None, context=None, workspace=None):
+        super().__init__(client, operation_name="CollectionGroupOperations", logger=logger, context=context, workspace=workspace)
+
+    @handle_rest_errors
+    def get_collection_group(self, group_id: str) -> CollectionGroupResponse:
+        self._validate_required_params({"group_id": group_id}, ["group_id"])
+        self._log_operation("getCollectionGroup", {"id": group_id})
+        try:
+            r = self.client.getCollectionGroup(id=group_id, **self._build_context_params())
+        except Exception as e:
+            if "404" in str(e): raise NotFoundError(group_id, "CollectionGroup")
+            raise
+        return CollectionGroupResponse(**r) if isinstance(r, dict) else r
+
+    @handle_rest_errors
+    def get_collection_group_children(self, group_id: str) -> list[str]:
+        self._validate_required_params({"group_id": group_id}, ["group_id"])
+        self._log_operation("getCollectionGroupChildren", {"id": group_id})
+        try:
+            r = self.client.getCollectionGroupChildren(id=group_id, **self._build_context_params())
+        except Exception as e:
+            if "404" in str(e): raise NotFoundError(group_id, "CollectionGroup")
+            raise
+        return r if isinstance(r, list) else []
+
+    @handle_rest_errors
+    def get_collection_group_collections(self, group_id: str) -> list[dict[str, Any]]:
+        self._validate_required_params({"group_id": group_id}, ["group_id"])
+        self._log_operation("getCollectionGroupCollections", {"id": group_id})
+        try:
+            r = self.client.getCollectionGroupCollections(id=group_id, **self._build_context_params())
+        except Exception as e:
+            if "404" in str(e): raise NotFoundError(group_id, "CollectionGroup")
+            raise
+        return r if isinstance(r, list) else []