capo-workdocs 0.1.0__py3-none-any.whl

capo_workdocs/errors/__init__.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+from ._base import (
+    DeserializationError as DeserializationError,
+)
+from ._base import (
+    SerializationError as SerializationError,
+)
+from ._base import (
+    ServiceError as ServiceError,
+)
+from ._base import (
+    UnknownServiceError as UnknownServiceError,
+)
+from ._base import (
+    WaiterFailedError as WaiterFailedError,
+)
+from ._base import (
+    WaiterTimeoutError as WaiterTimeoutError,
+)
+from ._base import (
+    WorkDocsError as WorkDocsError,
+)
+from .concurrent_modification_exception import (
+    ConcurrentModificationException as ConcurrentModificationException,
+)
+from .conflicting_operation_exception import (
+    ConflictingOperationException as ConflictingOperationException,
+)
+from .custom_metadata_limit_exceeded_exception import (
+    CustomMetadataLimitExceededException as CustomMetadataLimitExceededException,
+)
+from .deactivating_last_system_user_exception import (
+    DeactivatingLastSystemUserException as DeactivatingLastSystemUserException,
+)
+from .document_locked_for_comments_exception import (
+    DocumentLockedForCommentsException as DocumentLockedForCommentsException,
+)
+from .draft_upload_out_of_sync_exception import (
+    DraftUploadOutOfSyncException as DraftUploadOutOfSyncException,
+)
+from .entity_already_exists_exception import (
+    EntityAlreadyExistsException as EntityAlreadyExistsException,
+)
+from .entity_not_exists_exception import (
+    EntityNotExistsException as EntityNotExistsException,
+)
+from .failed_dependency_exception import (
+    FailedDependencyException as FailedDependencyException,
+)
+from .illegal_user_state_exception import (
+    IllegalUserStateException as IllegalUserStateException,
+)
+from .invalid_argument_exception import (
+    InvalidArgumentException as InvalidArgumentException,
+)
+from .invalid_comment_operation_exception import (
+    InvalidCommentOperationException as InvalidCommentOperationException,
+)
+from .invalid_operation_exception import (
+    InvalidOperationException as InvalidOperationException,
+)
+from .invalid_password_exception import (
+    InvalidPasswordException as InvalidPasswordException,
+)
+from .limit_exceeded_exception import LimitExceededException as LimitExceededException
+from .prohibited_state_exception import (
+    ProhibitedStateException as ProhibitedStateException,
+)
+from .requested_entity_too_large_exception import (
+    RequestedEntityTooLargeException as RequestedEntityTooLargeException,
+)
+from .resource_already_checked_out_exception import (
+    ResourceAlreadyCheckedOutException as ResourceAlreadyCheckedOutException,
+)
+from .service_unavailable_exception import (
+    ServiceUnavailableException as ServiceUnavailableException,
+)
+from .storage_limit_exceeded_exception import (
+    StorageLimitExceededException as StorageLimitExceededException,
+)
+from .storage_limit_will_exceed_exception import (
+    StorageLimitWillExceedException as StorageLimitWillExceedException,
+)
+from .too_many_labels_exception import TooManyLabelsException as TooManyLabelsException
+from .too_many_subscriptions_exception import (
+    TooManySubscriptionsException as TooManySubscriptionsException,
+)
+from .unauthorized_operation_exception import (
+    UnauthorizedOperationException as UnauthorizedOperationException,
+)
+from .unauthorized_resource_access_exception import (
+    UnauthorizedResourceAccessException as UnauthorizedResourceAccessException,
+)

capo_workdocs/errors/_base.py

@@ -0,0 +1,94 @@
+from typing import Literal
+
+
+class WorkDocsError(Exception):
+    """Base class for all WorkDocs service errors."""
+
+
+class ServiceError(WorkDocsError):
+    """Base class for all modeled service errors.
+
+    Args:
+        fault: ``"client"`` or ``"server"``.
+        is_throttling_error: Whether this error is a throttling error.
+        is_retryable: Whether this error is retryable.
+        code: The wire error code, or ``None``.
+        message: The error message, or ``None``.
+    """
+
+    code: str | None = None
+
+    def __init__(
+        self,
+        fault: Literal["client", "server"],
+        *,
+        is_throttling_error: bool,
+        is_retryable: bool,
+        code: str | None = None,
+        message: str | None = None,
+    ) -> None:
+        super().__init__(f"{code or '<no code>'}: {message or '<no message>'}")
+        self.fault = fault
+        self.is_throttling_error = is_throttling_error
+        self.is_retryable = is_retryable
+        self.code = code
+        self.message = message
+
+
+class SerializationError(WorkDocsError):
+    """Raised when a value cannot be serialized."""
+
+
+class DeserializationError(WorkDocsError):
+    """Raised when a value cannot be deserialized or a required member is missing."""
+
+
+class UnknownServiceError(ServiceError):
+    """Raised when the server returns an error code the client does not model.
+
+    Args:
+        code: ``<Code>`` text from the response body, or ``None`` if absent.
+        message: ``<Message>`` text from the response body, or ``None``.
+        response: The original HTTP response object, for arbitrary inspection.
+    """
+
+    def __init__(
+        self, *, code: str | None, message: str | None, response: object
+    ) -> None:
+        _status = getattr(response, "status", 500)
+        _fault: Literal["client", "server"] = "client" if _status < 500 else "server"
+        _throttling = _status == 429
+        _retryable = _throttling or _status >= 500
+        super().__init__(
+            _fault,
+            is_throttling_error=_throttling,
+            is_retryable=_retryable,
+            code=code,
+            message=message,
+        )
+        self.response = response
+
+
+class WaiterFailedError(WorkDocsError):
+    """Raised when a waiter hits an acceptor with ``state="failure"``.
+
+    Args:
+        waiter_name: snake_case waiter name (e.g. ``bucket_exists``).
+        reason: Short description of which acceptor fired.
+    """
+
+    def __init__(self, waiter_name: str, reason: str) -> None:
+        super().__init__(f"waiter {waiter_name} failed: {reason}")
+        self.waiter_name = waiter_name
+        self.reason = reason
+
+
+class WaiterTimeoutError(WorkDocsError):
+    """Raised when a waiter exhausts ``max_wait_time`` without a terminal acceptor."""
+
+    def __init__(self, waiter_name: str, max_wait_time: float) -> None:
+        super().__init__(
+            f"waiter {waiter_name} timed out after {max_wait_time} seconds"
+        )
+        self.waiter_name = waiter_name
+        self.max_wait_time = max_wait_time

capo_workdocs/errors/concurrent_modification_exception.py

@@ -0,0 +1,53 @@
+"""Generated from Smithy shape ``com.amazonaws.workdocs#ConcurrentModificationException``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_workdocs.errors import ServiceError
+
+if TYPE_CHECKING:
+    import capo_workdocs.types.error_message_type
+
+
+class ConcurrentModificationException_(TypedDict, closed=True):
+    message: NotRequired["capo_workdocs.types.error_message_type.ErrorMessageType"]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ConcurrentModificationException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["Message"] = value["message"]
+    return out
+
+
+def deserialize_json(data: dict) -> ConcurrentModificationException_:
+    out: ConcurrentModificationException_ = {}  # type: ignore[typeddict-item]
+    if data.get("Message") is not None:
+        out["message"] = data["Message"]
+    return out
+
+
+class ConcurrentModificationException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.workdocs#ConcurrentModificationException``."""
+
+    code: str | None = "ConcurrentModificationException"
+
+    def __init__(
+        self, data: ConcurrentModificationException_, message: str | None = None
+    ):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="ConcurrentModificationException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_json(
+        cls, data: dict, message: str | None = None
+    ) -> "ConcurrentModificationException":
+        return cls(deserialize_json(data), message)

capo_workdocs/errors/conflicting_operation_exception.py

@@ -0,0 +1,53 @@
+"""Generated from Smithy shape ``com.amazonaws.workdocs#ConflictingOperationException``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_workdocs.errors import ServiceError
+
+if TYPE_CHECKING:
+    import capo_workdocs.types.error_message_type
+
+
+class ConflictingOperationException_(TypedDict, closed=True):
+    message: NotRequired["capo_workdocs.types.error_message_type.ErrorMessageType"]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ConflictingOperationException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["Message"] = value["message"]
+    return out
+
+
+def deserialize_json(data: dict) -> ConflictingOperationException_:
+    out: ConflictingOperationException_ = {}  # type: ignore[typeddict-item]
+    if data.get("Message") is not None:
+        out["message"] = data["Message"]
+    return out
+
+
+class ConflictingOperationException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.workdocs#ConflictingOperationException``."""
+
+    code: str | None = "ConflictingOperationException"
+
+    def __init__(
+        self, data: ConflictingOperationException_, message: str | None = None
+    ):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="ConflictingOperationException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_json(
+        cls, data: dict, message: str | None = None
+    ) -> "ConflictingOperationException":
+        return cls(deserialize_json(data), message)

capo_workdocs/errors/custom_metadata_limit_exceeded_exception.py

@@ -0,0 +1,53 @@
+"""Generated from Smithy shape ``com.amazonaws.workdocs#CustomMetadataLimitExceededException``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_workdocs.errors import ServiceError
+
+if TYPE_CHECKING:
+    import capo_workdocs.types.error_message_type
+
+
+class CustomMetadataLimitExceededException_(TypedDict, closed=True):
+    message: NotRequired["capo_workdocs.types.error_message_type.ErrorMessageType"]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: CustomMetadataLimitExceededException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["Message"] = value["message"]
+    return out
+
+
+def deserialize_json(data: dict) -> CustomMetadataLimitExceededException_:
+    out: CustomMetadataLimitExceededException_ = {}  # type: ignore[typeddict-item]
+    if data.get("Message") is not None:
+        out["message"] = data["Message"]
+    return out
+
+
+class CustomMetadataLimitExceededException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.workdocs#CustomMetadataLimitExceededException``."""
+
+    code: str | None = "CustomMetadataLimitExceededException"
+
+    def __init__(
+        self, data: CustomMetadataLimitExceededException_, message: str | None = None
+    ):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="CustomMetadataLimitExceededException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_json(
+        cls, data: dict, message: str | None = None
+    ) -> "CustomMetadataLimitExceededException":
+        return cls(deserialize_json(data), message)

capo_workdocs/errors/deactivating_last_system_user_exception.py

@@ -0,0 +1,59 @@
+"""Generated from Smithy shape ``com.amazonaws.workdocs#DeactivatingLastSystemUserException``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_workdocs.errors import ServiceError
+
+if TYPE_CHECKING:
+    import capo_workdocs.types.error_message_type
+    import capo_workdocs.types.exception_code_type
+
+
+class DeactivatingLastSystemUserException_(TypedDict, closed=True):
+    message: NotRequired["capo_workdocs.types.error_message_type.ErrorMessageType"]
+    code: NotRequired["capo_workdocs.types.exception_code_type.ExceptionCodeType"]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: DeactivatingLastSystemUserException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["Message"] = value["message"]
+    if "code" in value:
+        out["Code"] = value["code"]
+    return out
+
+
+def deserialize_json(data: dict) -> DeactivatingLastSystemUserException_:
+    out: DeactivatingLastSystemUserException_ = {}  # type: ignore[typeddict-item]
+    if data.get("Message") is not None:
+        out["message"] = data["Message"]
+    if data.get("Code") is not None:
+        out["code"] = data["Code"]
+    return out
+
+
+class DeactivatingLastSystemUserException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.workdocs#DeactivatingLastSystemUserException``."""
+
+    code: str | None = "DeactivatingLastSystemUserException"
+
+    def __init__(
+        self, data: DeactivatingLastSystemUserException_, message: str | None = None
+    ):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="DeactivatingLastSystemUserException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_json(
+        cls, data: dict, message: str | None = None
+    ) -> "DeactivatingLastSystemUserException":
+        return cls(deserialize_json(data), message)

capo_workdocs/errors/document_locked_for_comments_exception.py

@@ -0,0 +1,53 @@
+"""Generated from Smithy shape ``com.amazonaws.workdocs#DocumentLockedForCommentsException``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_workdocs.errors import ServiceError
+
+if TYPE_CHECKING:
+    import capo_workdocs.types.error_message_type
+
+
+class DocumentLockedForCommentsException_(TypedDict, closed=True):
+    message: NotRequired["capo_workdocs.types.error_message_type.ErrorMessageType"]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: DocumentLockedForCommentsException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["Message"] = value["message"]
+    return out
+
+
+def deserialize_json(data: dict) -> DocumentLockedForCommentsException_:
+    out: DocumentLockedForCommentsException_ = {}  # type: ignore[typeddict-item]
+    if data.get("Message") is not None:
+        out["message"] = data["Message"]
+    return out
+
+
+class DocumentLockedForCommentsException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.workdocs#DocumentLockedForCommentsException``."""
+
+    code: str | None = "DocumentLockedForCommentsException"
+
+    def __init__(
+        self, data: DocumentLockedForCommentsException_, message: str | None = None
+    ):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="DocumentLockedForCommentsException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_json(
+        cls, data: dict, message: str | None = None
+    ) -> "DocumentLockedForCommentsException":
+        return cls(deserialize_json(data), message)

capo_workdocs/errors/draft_upload_out_of_sync_exception.py

@@ -0,0 +1,53 @@
+"""Generated from Smithy shape ``com.amazonaws.workdocs#DraftUploadOutOfSyncException``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_workdocs.errors import ServiceError
+
+if TYPE_CHECKING:
+    import capo_workdocs.types.error_message_type
+
+
+class DraftUploadOutOfSyncException_(TypedDict, closed=True):
+    message: NotRequired["capo_workdocs.types.error_message_type.ErrorMessageType"]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: DraftUploadOutOfSyncException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["Message"] = value["message"]
+    return out
+
+
+def deserialize_json(data: dict) -> DraftUploadOutOfSyncException_:
+    out: DraftUploadOutOfSyncException_ = {}  # type: ignore[typeddict-item]
+    if data.get("Message") is not None:
+        out["message"] = data["Message"]
+    return out
+
+
+class DraftUploadOutOfSyncException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.workdocs#DraftUploadOutOfSyncException``."""
+
+    code: str | None = "DraftUploadOutOfSyncException"
+
+    def __init__(
+        self, data: DraftUploadOutOfSyncException_, message: str | None = None
+    ):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="DraftUploadOutOfSyncException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_json(
+        cls, data: dict, message: str | None = None
+    ) -> "DraftUploadOutOfSyncException":
+        return cls(deserialize_json(data), message)

capo_workdocs/errors/entity_already_exists_exception.py

@@ -0,0 +1,51 @@
+"""Generated from Smithy shape ``com.amazonaws.workdocs#EntityAlreadyExistsException``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_workdocs.errors import ServiceError
+
+if TYPE_CHECKING:
+    import capo_workdocs.types.error_message_type
+
+
+class EntityAlreadyExistsException_(TypedDict, closed=True):
+    message: NotRequired["capo_workdocs.types.error_message_type.ErrorMessageType"]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: EntityAlreadyExistsException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["Message"] = value["message"]
+    return out
+
+
+def deserialize_json(data: dict) -> EntityAlreadyExistsException_:
+    out: EntityAlreadyExistsException_ = {}  # type: ignore[typeddict-item]
+    if data.get("Message") is not None:
+        out["message"] = data["Message"]
+    return out
+
+
+class EntityAlreadyExistsException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.workdocs#EntityAlreadyExistsException``."""
+
+    code: str | None = "EntityAlreadyExistsException"
+
+    def __init__(self, data: EntityAlreadyExistsException_, message: str | None = None):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="EntityAlreadyExistsException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_json(
+        cls, data: dict, message: str | None = None
+    ) -> "EntityAlreadyExistsException":
+        return cls(deserialize_json(data), message)

capo_workdocs/errors/entity_not_exists_exception.py

@@ -0,0 +1,66 @@
+"""Generated from Smithy shape ``com.amazonaws.workdocs#EntityNotExistsException``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_workdocs.errors import ServiceError
+
+if TYPE_CHECKING:
+    import capo_workdocs.types.entity_id_list
+    import capo_workdocs.types.error_message_type
+
+
+class EntityNotExistsException_(TypedDict, closed=True):
+    message: NotRequired["capo_workdocs.types.error_message_type.ErrorMessageType"]
+    entity_ids: NotRequired["capo_workdocs.types.entity_id_list.EntityIdList"]
+    """<p>The IDs of the non-existent resources.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: EntityNotExistsException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["Message"] = value["message"]
+    if "entity_ids" in value:
+        import capo_workdocs.types.entity_id_list
+
+        out["EntityIds"] = capo_workdocs.types.entity_id_list.serialize_json(
+            value["entity_ids"]
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> EntityNotExistsException_:
+    out: EntityNotExistsException_ = {}  # type: ignore[typeddict-item]
+    if data.get("Message") is not None:
+        out["message"] = data["Message"]
+    if data.get("EntityIds") is not None:
+        import capo_workdocs.types.entity_id_list
+
+        out["entity_ids"] = capo_workdocs.types.entity_id_list.deserialize_json(
+            data["EntityIds"]
+        )
+    return out
+
+
+class EntityNotExistsException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.workdocs#EntityNotExistsException``."""
+
+    code: str | None = "EntityNotExistsException"
+
+    def __init__(self, data: EntityNotExistsException_, message: str | None = None):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="EntityNotExistsException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_json(
+        cls, data: dict, message: str | None = None
+    ) -> "EntityNotExistsException":
+        return cls(deserialize_json(data), message)

capo_workdocs/errors/failed_dependency_exception.py

@@ -0,0 +1,51 @@
+"""Generated from Smithy shape ``com.amazonaws.workdocs#FailedDependencyException``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_workdocs.errors import ServiceError
+
+if TYPE_CHECKING:
+    import capo_workdocs.types.error_message_type
+
+
+class FailedDependencyException_(TypedDict, closed=True):
+    message: NotRequired["capo_workdocs.types.error_message_type.ErrorMessageType"]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: FailedDependencyException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["Message"] = value["message"]
+    return out
+
+
+def deserialize_json(data: dict) -> FailedDependencyException_:
+    out: FailedDependencyException_ = {}  # type: ignore[typeddict-item]
+    if data.get("Message") is not None:
+        out["message"] = data["Message"]
+    return out
+
+
+class FailedDependencyException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.workdocs#FailedDependencyException``."""
+
+    code: str | None = "FailedDependencyException"
+
+    def __init__(self, data: FailedDependencyException_, message: str | None = None):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="FailedDependencyException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_json(
+        cls, data: dict, message: str | None = None
+    ) -> "FailedDependencyException":
+        return cls(deserialize_json(data), message)