capo-keyspaces 0.1.0__py3-none-any.whl

capo_keyspaces/errors/__init__.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from ._base import (
+    DeserializationError as DeserializationError,
+)
+from ._base import (
+    KeyspacesError as KeyspacesError,
+)
+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 .access_denied_exception import AccessDeniedException as AccessDeniedException
+from .conflict_exception import ConflictException as ConflictException
+from .internal_server_exception import (
+    InternalServerException as InternalServerException,
+)
+from .resource_not_found_exception import (
+    ResourceNotFoundException as ResourceNotFoundException,
+)
+from .service_quota_exceeded_exception import (
+    ServiceQuotaExceededException as ServiceQuotaExceededException,
+)
+from .validation_exception import ValidationException as ValidationException

capo_keyspaces/errors/_base.py

@@ -0,0 +1,94 @@
+from typing import Literal
+
+
+class KeyspacesError(Exception):
+    """Base class for all Keyspaces service errors."""
+
+
+class ServiceError(KeyspacesError):
+    """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(KeyspacesError):
+    """Raised when a value cannot be serialized."""
+
+
+class DeserializationError(KeyspacesError):
+    """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(KeyspacesError):
+    """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(KeyspacesError):
+    """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_keyspaces/errors/access_denied_exception.py

@@ -0,0 +1,47 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspaces#AccessDeniedException``."""
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_keyspaces.errors import ServiceError
+
+
+class AccessDeniedException_(TypedDict, closed=True):
+    message: NotRequired["str"]
+    """<p>You don't have the required permissions to perform this operation. Verify your IAM permissions and try again.</p>"""
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: AccessDeniedException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["message"] = value["message"]
+    return out
+
+
+def deserialize_aws_json_1_0(data: dict) -> AccessDeniedException_:
+    out: AccessDeniedException_ = {}  # type: ignore[typeddict-item]
+    if data.get("message") is not None:
+        out["message"] = data["message"]
+    return out
+
+
+class AccessDeniedException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.keyspaces#AccessDeniedException``."""
+
+    code: str | None = "AccessDeniedException"
+
+    def __init__(self, data: AccessDeniedException_, message: str | None = None):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="AccessDeniedException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_aws_json_1_0(
+        cls, data: dict, message: str | None = None
+    ) -> "AccessDeniedException":
+        return cls(deserialize_aws_json_1_0(data), message)

capo_keyspaces/errors/conflict_exception.py

@@ -0,0 +1,47 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspaces#ConflictException``."""
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_keyspaces.errors import ServiceError
+
+
+class ConflictException_(TypedDict, closed=True):
+    message: NotRequired["str"]
+    """<p>The requested operation conflicts with the current state of the resource or another concurrent operation.</p>"""
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: ConflictException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["message"] = value["message"]
+    return out
+
+
+def deserialize_aws_json_1_0(data: dict) -> ConflictException_:
+    out: ConflictException_ = {}  # type: ignore[typeddict-item]
+    if data.get("message") is not None:
+        out["message"] = data["message"]
+    return out
+
+
+class ConflictException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.keyspaces#ConflictException``."""
+
+    code: str | None = "ConflictException"
+
+    def __init__(self, data: ConflictException_, message: str | None = None):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="ConflictException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_aws_json_1_0(
+        cls, data: dict, message: str | None = None
+    ) -> "ConflictException":
+        return cls(deserialize_aws_json_1_0(data), message)

capo_keyspaces/errors/internal_server_exception.py

@@ -0,0 +1,47 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspaces#InternalServerException``."""
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_keyspaces.errors import ServiceError
+
+
+class InternalServerException_(TypedDict, closed=True):
+    message: NotRequired["str"]
+    """<p>An internal service error occurred. Retry your request. If the problem persists, contact Amazon Web Services Support.</p>"""
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: InternalServerException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["message"] = value["message"]
+    return out
+
+
+def deserialize_aws_json_1_0(data: dict) -> InternalServerException_:
+    out: InternalServerException_ = {}  # type: ignore[typeddict-item]
+    if data.get("message") is not None:
+        out["message"] = data["message"]
+    return out
+
+
+class InternalServerException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.keyspaces#InternalServerException``."""
+
+    code: str | None = "InternalServerException"
+
+    def __init__(self, data: InternalServerException_, message: str | None = None):
+        super().__init__(
+            "server",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="InternalServerException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_aws_json_1_0(
+        cls, data: dict, message: str | None = None
+    ) -> "InternalServerException":
+        return cls(deserialize_aws_json_1_0(data), message)

capo_keyspaces/errors/resource_not_found_exception.py

@@ -0,0 +1,58 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspaces#ResourceNotFoundException``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_keyspaces.errors import ServiceError
+
+if TYPE_CHECKING:
+    import capo_keyspaces.types.arn
+
+
+class ResourceNotFoundException_(TypedDict, closed=True):
+    message: NotRequired["str"]
+    """<p>The specified resource was not found. Verify the resource identifier and ensure the resource exists and is in an ACTIVE state.</p>"""
+    resource_arn: NotRequired["capo_keyspaces.types.arn.ARN"]
+    """<p>The unique identifier in the format of Amazon Resource Name (ARN) for the resource couldn't be found.</p>"""
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: ResourceNotFoundException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["message"] = value["message"]
+    if "resource_arn" in value:
+        out["resourceArn"] = value["resource_arn"]
+    return out
+
+
+def deserialize_aws_json_1_0(data: dict) -> ResourceNotFoundException_:
+    out: ResourceNotFoundException_ = {}  # type: ignore[typeddict-item]
+    if data.get("message") is not None:
+        out["message"] = data["message"]
+    if data.get("resourceArn") is not None:
+        out["resource_arn"] = data["resourceArn"]
+    return out
+
+
+class ResourceNotFoundException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.keyspaces#ResourceNotFoundException``."""
+
+    code: str | None = "ResourceNotFoundException"
+
+    def __init__(self, data: ResourceNotFoundException_, message: str | None = None):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="ResourceNotFoundException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_aws_json_1_0(
+        cls, data: dict, message: str | None = None
+    ) -> "ResourceNotFoundException":
+        return cls(deserialize_aws_json_1_0(data), message)

capo_keyspaces/errors/service_quota_exceeded_exception.py

@@ -0,0 +1,49 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspaces#ServiceQuotaExceededException``."""
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_keyspaces.errors import ServiceError
+
+
+class ServiceQuotaExceededException_(TypedDict, closed=True):
+    message: NotRequired["str"]
+    """<p>The requested operation would exceed the service quota for this resource. Review the service quotas and adjust your request accordingly.</p>"""
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: ServiceQuotaExceededException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["message"] = value["message"]
+    return out
+
+
+def deserialize_aws_json_1_0(data: dict) -> ServiceQuotaExceededException_:
+    out: ServiceQuotaExceededException_ = {}  # type: ignore[typeddict-item]
+    if data.get("message") is not None:
+        out["message"] = data["message"]
+    return out
+
+
+class ServiceQuotaExceededException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.keyspaces#ServiceQuotaExceededException``."""
+
+    code: str | None = "ServiceQuotaExceededException"
+
+    def __init__(
+        self, data: ServiceQuotaExceededException_, message: str | None = None
+    ):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="ServiceQuotaExceededException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_aws_json_1_0(
+        cls, data: dict, message: str | None = None
+    ) -> "ServiceQuotaExceededException":
+        return cls(deserialize_aws_json_1_0(data), message)

capo_keyspaces/errors/validation_exception.py

@@ -0,0 +1,47 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspaces#ValidationException``."""
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_keyspaces.errors import ServiceError
+
+
+class ValidationException_(TypedDict, closed=True):
+    message: NotRequired["str"]
+    """<p>The request parameters are invalid or malformed. Review the API documentation and correct the request format.</p>"""
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: ValidationException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["message"] = value["message"]
+    return out
+
+
+def deserialize_aws_json_1_0(data: dict) -> ValidationException_:
+    out: ValidationException_ = {}  # type: ignore[typeddict-item]
+    if data.get("message") is not None:
+        out["message"] = data["message"]
+    return out
+
+
+class ValidationException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.keyspaces#ValidationException``."""
+
+    code: str | None = "ValidationException"
+
+    def __init__(self, data: ValidationException_, message: str | None = None):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="ValidationException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_aws_json_1_0(
+        cls, data: dict, message: str | None = None
+    ) -> "ValidationException":
+        return cls(deserialize_aws_json_1_0(data), message)

capo_keyspaces/types/_prelude/blob.py

@@ -0,0 +1,12 @@
+"""Generated from Smithy prelude shape ``smithy.api#Blob``."""
+
+import base64
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: bytes) -> str:
+    return base64.b64encode(value).decode("ascii")
+
+
+def deserialize_aws_json_1_0(data: str) -> bytes:
+    return base64.b64decode(data)

capo_keyspaces/types/_prelude/timestamp.py

@@ -0,0 +1,17 @@
+"""Generated from Smithy prelude shape ``smithy.api#Timestamp``."""
+
+import datetime
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: datetime.datetime) -> float:
+    value = (
+        value.astimezone(datetime.timezone.utc)
+        if value.tzinfo
+        else value.replace(tzinfo=datetime.timezone.utc)
+    )
+    return value.timestamp()
+
+
+def deserialize_aws_json_1_0(data: float) -> datetime.datetime:
+    return datetime.datetime.fromtimestamp(float(data), tz=datetime.timezone.utc)

capo_keyspaces/types/arn.py

@@ -0,0 +1,5 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspaces#ARN``."""
+
+from typing import TypeAlias
+
+ARN: TypeAlias = str

capo_keyspaces/types/auto_scaling_policy.py

@@ -0,0 +1,42 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspaces#AutoScalingPolicy``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_keyspaces.types.target_tracking_scaling_policy_configuration
+
+
+class AutoScalingPolicy(TypedDict, closed=True):
+    target_tracking_scaling_policy_configuration: NotRequired[
+        "capo_keyspaces.types.target_tracking_scaling_policy_configuration.TargetTrackingScalingPolicyConfiguration"
+    ]
+    """<p>Auto scaling scales up capacity automatically when traffic exceeds this target utilization rate, and then back down when it falls below the target. A <code>double</code> between 20 and 90.</p>"""
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: AutoScalingPolicy) -> dict:
+    out: dict = {}
+    if "target_tracking_scaling_policy_configuration" in value:
+        import capo_keyspaces.types.target_tracking_scaling_policy_configuration
+
+        out["targetTrackingScalingPolicyConfiguration"] = (
+            capo_keyspaces.types.target_tracking_scaling_policy_configuration.serialize_aws_json_1_0(
+                value["target_tracking_scaling_policy_configuration"]
+            )
+        )
+    return out
+
+
+def deserialize_aws_json_1_0(data: dict) -> AutoScalingPolicy:
+    out: AutoScalingPolicy = {}  # type: ignore[typeddict-item]
+    if data.get("targetTrackingScalingPolicyConfiguration") is not None:
+        import capo_keyspaces.types.target_tracking_scaling_policy_configuration
+
+        out["target_tracking_scaling_policy_configuration"] = (
+            capo_keyspaces.types.target_tracking_scaling_policy_configuration.deserialize_aws_json_1_0(
+                data["targetTrackingScalingPolicyConfiguration"]
+            )
+        )
+    return out

capo_keyspaces/types/auto_scaling_settings.py

@@ -0,0 +1,63 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspaces#AutoScalingSettings``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_keyspaces.types.auto_scaling_policy
+    import capo_keyspaces.types.boolean_object
+    import capo_keyspaces.types.capacity_units
+
+
+class AutoScalingSettings(TypedDict, closed=True):
+    auto_scaling_disabled: "capo_keyspaces.types.boolean_object.BooleanObject"
+    """<p>This optional parameter enables auto scaling for the table if set to <code>false</code>.</p>"""
+    minimum_units: NotRequired["capo_keyspaces.types.capacity_units.CapacityUnits"]
+    """<p>The minimum level of throughput the table should always be ready to support. The value must be between 1 and the max throughput per second quota for your account (40,000 by default).</p>"""
+    maximum_units: NotRequired["capo_keyspaces.types.capacity_units.CapacityUnits"]
+    """<p>Manage costs by specifying the maximum amount of throughput to provision. The value must be between 1 and the max throughput per second quota for your account (40,000 by default).</p>"""
+    scaling_policy: NotRequired[
+        "capo_keyspaces.types.auto_scaling_policy.AutoScalingPolicy"
+    ]
+    """<p>Amazon Keyspaces supports the <code>target tracking</code> auto scaling policy. With this policy, Amazon Keyspaces auto scaling ensures that the table's ratio of consumed to provisioned capacity stays at or near the target value that you specify. You define the target value as a percentage between 20 and 90.</p>"""
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: AutoScalingSettings) -> dict:
+    out: dict = {}
+    out["autoScalingDisabled"] = value.get("auto_scaling_disabled", False)
+    if "minimum_units" in value:
+        out["minimumUnits"] = value["minimum_units"]
+    if "maximum_units" in value:
+        out["maximumUnits"] = value["maximum_units"]
+    if "scaling_policy" in value:
+        import capo_keyspaces.types.auto_scaling_policy
+
+        out["scalingPolicy"] = (
+            capo_keyspaces.types.auto_scaling_policy.serialize_aws_json_1_0(
+                value["scaling_policy"]
+            )
+        )
+    return out
+
+
+def deserialize_aws_json_1_0(data: dict) -> AutoScalingSettings:
+    out: AutoScalingSettings = {}  # type: ignore[typeddict-item]
+    if data.get("autoScalingDisabled") is not None:
+        out["auto_scaling_disabled"] = data["autoScalingDisabled"]
+    else:
+        out["auto_scaling_disabled"] = False
+    if data.get("minimumUnits") is not None:
+        out["minimum_units"] = data["minimumUnits"]
+    if data.get("maximumUnits") is not None:
+        out["maximum_units"] = data["maximumUnits"]
+    if data.get("scalingPolicy") is not None:
+        import capo_keyspaces.types.auto_scaling_policy
+
+        out["scaling_policy"] = (
+            capo_keyspaces.types.auto_scaling_policy.deserialize_aws_json_1_0(
+                data["scalingPolicy"]
+            )
+        )
+    return out

capo_keyspaces/types/auto_scaling_specification.py

@@ -0,0 +1,62 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspaces#AutoScalingSpecification``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_keyspaces.types.auto_scaling_settings
+
+
+class AutoScalingSpecification(TypedDict, closed=True):
+    write_capacity_auto_scaling: NotRequired[
+        "capo_keyspaces.types.auto_scaling_settings.AutoScalingSettings"
+    ]
+    """<p>The auto scaling settings for the table's write capacity.</p>"""
+    read_capacity_auto_scaling: NotRequired[
+        "capo_keyspaces.types.auto_scaling_settings.AutoScalingSettings"
+    ]
+    """<p>The auto scaling settings for the table's read capacity.</p>"""
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: AutoScalingSpecification) -> dict:
+    out: dict = {}
+    if "write_capacity_auto_scaling" in value:
+        import capo_keyspaces.types.auto_scaling_settings
+
+        out["writeCapacityAutoScaling"] = (
+            capo_keyspaces.types.auto_scaling_settings.serialize_aws_json_1_0(
+                value["write_capacity_auto_scaling"]
+            )
+        )
+    if "read_capacity_auto_scaling" in value:
+        import capo_keyspaces.types.auto_scaling_settings
+
+        out["readCapacityAutoScaling"] = (
+            capo_keyspaces.types.auto_scaling_settings.serialize_aws_json_1_0(
+                value["read_capacity_auto_scaling"]
+            )
+        )
+    return out
+
+
+def deserialize_aws_json_1_0(data: dict) -> AutoScalingSpecification:
+    out: AutoScalingSpecification = {}  # type: ignore[typeddict-item]
+    if data.get("writeCapacityAutoScaling") is not None:
+        import capo_keyspaces.types.auto_scaling_settings
+
+        out["write_capacity_auto_scaling"] = (
+            capo_keyspaces.types.auto_scaling_settings.deserialize_aws_json_1_0(
+                data["writeCapacityAutoScaling"]
+            )
+        )
+    if data.get("readCapacityAutoScaling") is not None:
+        import capo_keyspaces.types.auto_scaling_settings
+
+        out["read_capacity_auto_scaling"] = (
+            capo_keyspaces.types.auto_scaling_settings.deserialize_aws_json_1_0(
+                data["readCapacityAutoScaling"]
+            )
+        )
+    return out

capo_keyspaces/types/boolean_object.py

@@ -0,0 +1,5 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspaces#BooleanObject``."""
+
+from typing import TypeAlias
+
+BooleanObject: TypeAlias = bool