capo-lambda-web 0.2.0__py3-none-any.whl

capo_lambda_web/errors/__init__.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+from ._base import (
+    DeserializationError as DeserializationError,
+)
+from ._base import (
+    LambdaWebError as LambdaWebError,
+)
+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 .throttling_exception import ThrottlingException as ThrottlingException
+from .validation_exception import ValidationException as ValidationException

capo_lambda_web/errors/_base.py

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

@@ -0,0 +1,48 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdaweb#AccessDeniedException``."""
+
+from typing_extensions import TypedDict
+
+from capo_lambda_web.errors import DeserializationError, ServiceError
+
+
+class AccessDeniedException_(TypedDict, closed=True):
+    message: "str"
+    """<p>A message describing the access denied error.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: AccessDeniedException_) -> dict:
+    out: dict = {}
+    out["message"] = value["message"]
+    return out
+
+
+def deserialize_json(data: dict) -> AccessDeniedException_:
+    out: AccessDeniedException_ = {}  # type: ignore[typeddict-item]
+    if data.get("message") is not None:
+        out["message"] = data["message"]
+    else:
+        raise DeserializationError("AccessDeniedException_.message required")
+    return out
+
+
+class AccessDeniedException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.lambdaweb#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_json(
+        cls, data: dict, message: str | None = None
+    ) -> "AccessDeniedException":
+        return cls(deserialize_json(data), message)

capo_lambda_web/errors/conflict_exception.py

@@ -0,0 +1,58 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdaweb#ConflictException``."""
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_lambda_web.errors import DeserializationError, ServiceError
+
+
+class ConflictException_(TypedDict, closed=True):
+    message: "str"
+    """<p>A message describing the conflict.</p>"""
+    resource_id: NotRequired["str"]
+    """<p>The identifier of the resource in conflict.</p>"""
+    resource_type: NotRequired["str"]
+    """<p>The type of the resource in conflict.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ConflictException_) -> dict:
+    out: dict = {}
+    out["message"] = value["message"]
+    if "resource_id" in value:
+        out["resourceId"] = value["resource_id"]
+    if "resource_type" in value:
+        out["resourceType"] = value["resource_type"]
+    return out
+
+
+def deserialize_json(data: dict) -> ConflictException_:
+    out: ConflictException_ = {}  # type: ignore[typeddict-item]
+    if data.get("message") is not None:
+        out["message"] = data["message"]
+    else:
+        raise DeserializationError("ConflictException_.message required")
+    if data.get("resourceId") is not None:
+        out["resource_id"] = data["resourceId"]
+    if data.get("resourceType") is not None:
+        out["resource_type"] = data["resourceType"]
+    return out
+
+
+class ConflictException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.lambdaweb#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_json(cls, data: dict, message: str | None = None) -> "ConflictException":
+        return cls(deserialize_json(data), message)

capo_lambda_web/errors/internal_server_exception.py

@@ -0,0 +1,47 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdaweb#InternalServerException``."""
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_lambda_web.errors import ServiceError
+
+
+class InternalServerException_(TypedDict, closed=True):
+    message: NotRequired["str"]
+    """<p>A message describing the internal error.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: InternalServerException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["message"] = value["message"]
+    return out
+
+
+def deserialize_json(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.lambdaweb#InternalServerException``."""
+
+    code: str | None = "InternalServerException"
+
+    def __init__(self, data: InternalServerException_, message: str | None = None):
+        super().__init__(
+            "server",
+            is_throttling_error=False,
+            is_retryable=True,
+            code="InternalServerException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_json(
+        cls, data: dict, message: str | None = None
+    ) -> "InternalServerException":
+        return cls(deserialize_json(data), message)

capo_lambda_web/errors/resource_not_found_exception.py

@@ -0,0 +1,60 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdaweb#ResourceNotFoundException``."""
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_lambda_web.errors import DeserializationError, ServiceError
+
+
+class ResourceNotFoundException_(TypedDict, closed=True):
+    message: "str"
+    """<p>A message describing the resource not found error.</p>"""
+    resource_id: NotRequired["str"]
+    """<p>The identifier of the resource that was not found.</p>"""
+    resource_type: NotRequired["str"]
+    """<p>The type of the resource that was not found.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ResourceNotFoundException_) -> dict:
+    out: dict = {}
+    out["message"] = value["message"]
+    if "resource_id" in value:
+        out["resourceId"] = value["resource_id"]
+    if "resource_type" in value:
+        out["resourceType"] = value["resource_type"]
+    return out
+
+
+def deserialize_json(data: dict) -> ResourceNotFoundException_:
+    out: ResourceNotFoundException_ = {}  # type: ignore[typeddict-item]
+    if data.get("message") is not None:
+        out["message"] = data["message"]
+    else:
+        raise DeserializationError("ResourceNotFoundException_.message required")
+    if data.get("resourceId") is not None:
+        out["resource_id"] = data["resourceId"]
+    if data.get("resourceType") is not None:
+        out["resource_type"] = data["resourceType"]
+    return out
+
+
+class ResourceNotFoundException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.lambdaweb#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_json(
+        cls, data: dict, message: str | None = None
+    ) -> "ResourceNotFoundException":
+        return cls(deserialize_json(data), message)

capo_lambda_web/errors/service_quota_exceeded_exception.py

@@ -0,0 +1,74 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdaweb#ServiceQuotaExceededException``."""
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_lambda_web.errors import DeserializationError, ServiceError
+
+
+class ServiceQuotaExceededException_(TypedDict, closed=True):
+    message: "str"
+    """<p>A message describing the quota that was exceeded.</p>"""
+    resource_id: NotRequired["str"]
+    """<p>The identifier of the resource that exceeded the quota.</p>"""
+    resource_type: NotRequired["str"]
+    """<p>The type of resource that exceeded the quota.</p>"""
+    service_code: NotRequired["str"]
+    """<p>The service code of the service that owns the quota.</p>"""
+    quota_code: NotRequired["str"]
+    """<p>The quota code of the exceeded quota.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ServiceQuotaExceededException_) -> dict:
+    out: dict = {}
+    out["message"] = value["message"]
+    if "resource_id" in value:
+        out["resourceId"] = value["resource_id"]
+    if "resource_type" in value:
+        out["resourceType"] = value["resource_type"]
+    if "service_code" in value:
+        out["serviceCode"] = value["service_code"]
+    if "quota_code" in value:
+        out["quotaCode"] = value["quota_code"]
+    return out
+
+
+def deserialize_json(data: dict) -> ServiceQuotaExceededException_:
+    out: ServiceQuotaExceededException_ = {}  # type: ignore[typeddict-item]
+    if data.get("message") is not None:
+        out["message"] = data["message"]
+    else:
+        raise DeserializationError("ServiceQuotaExceededException_.message required")
+    if data.get("resourceId") is not None:
+        out["resource_id"] = data["resourceId"]
+    if data.get("resourceType") is not None:
+        out["resource_type"] = data["resourceType"]
+    if data.get("serviceCode") is not None:
+        out["service_code"] = data["serviceCode"]
+    if data.get("quotaCode") is not None:
+        out["quota_code"] = data["quotaCode"]
+    return out
+
+
+class ServiceQuotaExceededException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.lambdaweb#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_json(
+        cls, data: dict, message: str | None = None
+    ) -> "ServiceQuotaExceededException":
+        return cls(deserialize_json(data), message)

capo_lambda_web/errors/throttling_exception.py

@@ -0,0 +1,60 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdaweb#ThrottlingException``."""
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_lambda_web.errors import DeserializationError, ServiceError
+
+
+class ThrottlingException_(TypedDict, closed=True):
+    message: "str"
+    """<p>A message describing the throttling error.</p>"""
+    retry_after_seconds: NotRequired["int"]
+    """<p>The number of seconds to wait before retrying the request.</p>"""
+    service_code: NotRequired["str"]
+    """<p>The service code of the throttled service.</p>"""
+    quota_code: NotRequired["str"]
+    """<p>The quota code that was exceeded, if applicable.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ThrottlingException_) -> dict:
+    out: dict = {}
+    out["message"] = value["message"]
+    if "service_code" in value:
+        out["serviceCode"] = value["service_code"]
+    if "quota_code" in value:
+        out["quotaCode"] = value["quota_code"]
+    return out
+
+
+def deserialize_json(data: dict) -> ThrottlingException_:
+    out: ThrottlingException_ = {}  # type: ignore[typeddict-item]
+    if data.get("message") is not None:
+        out["message"] = data["message"]
+    else:
+        raise DeserializationError("ThrottlingException_.message required")
+    if data.get("serviceCode") is not None:
+        out["service_code"] = data["serviceCode"]
+    if data.get("quotaCode") is not None:
+        out["quota_code"] = data["quotaCode"]
+    return out
+
+
+class ThrottlingException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.lambdaweb#ThrottlingException``."""
+
+    code: str | None = "ThrottlingException"
+
+    def __init__(self, data: ThrottlingException_, message: str | None = None):
+        super().__init__(
+            "client",
+            is_throttling_error=True,
+            is_retryable=True,
+            code="ThrottlingException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_json(cls, data: dict, message: str | None = None) -> "ThrottlingException":
+        return cls(deserialize_json(data), message)

capo_lambda_web/errors/validation_exception.py

@@ -0,0 +1,46 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdaweb#ValidationException``."""
+
+from typing_extensions import TypedDict
+
+from capo_lambda_web.errors import DeserializationError, ServiceError
+
+
+class ValidationException_(TypedDict, closed=True):
+    message: "str"
+    """<p>A message describing the validation error.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ValidationException_) -> dict:
+    out: dict = {}
+    out["message"] = value["message"]
+    return out
+
+
+def deserialize_json(data: dict) -> ValidationException_:
+    out: ValidationException_ = {}  # type: ignore[typeddict-item]
+    if data.get("message") is not None:
+        out["message"] = data["message"]
+    else:
+        raise DeserializationError("ValidationException_.message required")
+    return out
+
+
+class ValidationException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.lambdaweb#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_json(cls, data: dict, message: str | None = None) -> "ValidationException":
+        return cls(deserialize_json(data), message)

capo_lambda_web/types/_prelude/blob.py

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

capo_lambda_web/types/_prelude/timestamp.py

@@ -0,0 +1,17 @@
+"""Generated from Smithy prelude shape ``smithy.api#Timestamp``."""
+
+import datetime
+
+
+# --- restJson1 ser/de ---
+def serialize_json(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_json(data: float) -> datetime.datetime:
+    return datetime.datetime.fromtimestamp(float(data), tz=datetime.timezone.utc)

capo_lambda_web/types/account_quotas.py

@@ -0,0 +1,47 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdaweb#AccountQuotas``."""
+
+from typing_extensions import TypedDict
+
+from capo_lambda_web.errors import DeserializationError
+
+
+class AccountQuotas(TypedDict, closed=True):
+    max_total_arm_v_cpus: "int"
+    """<p>The maximum total number of Arm vCPUs that you can allocate across all of your web functions in the current AWS Region.</p>"""
+    max_total_rate_limit: "int"
+    """<p>The maximum number of requests per second allowed across all of your web function endpoints in your account in the current AWS Region.</p>"""
+    max_revisions_per_function: "int"
+    """<p>The maximum number of revisions that a single web function can have.</p>"""
+    max_endpoints_per_function: "int"
+    """<p>The maximum number of endpoints that a single web function can have.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: AccountQuotas) -> dict:
+    out: dict = {}
+    out["maxTotalArmVCpus"] = value["max_total_arm_v_cpus"]
+    out["maxTotalRateLimit"] = value["max_total_rate_limit"]
+    out["maxRevisionsPerFunction"] = value["max_revisions_per_function"]
+    out["maxEndpointsPerFunction"] = value["max_endpoints_per_function"]
+    return out
+
+
+def deserialize_json(data: dict) -> AccountQuotas:
+    out: AccountQuotas = {}  # type: ignore[typeddict-item]
+    if data.get("maxTotalArmVCpus") is not None:
+        out["max_total_arm_v_cpus"] = data["maxTotalArmVCpus"]
+    else:
+        raise DeserializationError("AccountQuotas.max_total_arm_v_cpus required")
+    if data.get("maxTotalRateLimit") is not None:
+        out["max_total_rate_limit"] = data["maxTotalRateLimit"]
+    else:
+        raise DeserializationError("AccountQuotas.max_total_rate_limit required")
+    if data.get("maxRevisionsPerFunction") is not None:
+        out["max_revisions_per_function"] = data["maxRevisionsPerFunction"]
+    else:
+        raise DeserializationError("AccountQuotas.max_revisions_per_function required")
+    if data.get("maxEndpointsPerFunction") is not None:
+        out["max_endpoints_per_function"] = data["maxEndpointsPerFunction"]
+    else:
+        raise DeserializationError("AccountQuotas.max_endpoints_per_function required")
+    return out

capo_lambda_web/types/account_usage.py

@@ -0,0 +1,26 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdaweb#AccountUsage``."""
+
+from typing_extensions import TypedDict
+
+from capo_lambda_web.errors import DeserializationError
+
+
+class AccountUsage(TypedDict, closed=True):
+    function_count: "int"
+    """<p>The number of web functions in your account in the current AWS Region.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: AccountUsage) -> dict:
+    out: dict = {}
+    out["functionCount"] = value["function_count"]
+    return out
+
+
+def deserialize_json(data: dict) -> AccountUsage:
+    out: AccountUsage = {}  # type: ignore[typeddict-item]
+    if data.get("functionCount") is not None:
+        out["function_count"] = data["functionCount"]
+    else:
+        raise DeserializationError("AccountUsage.function_count required")
+    return out

capo_lambda_web/types/application_log_level.py

@@ -0,0 +1,22 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdaweb#ApplicationLogLevel``."""
+
+from typing import Literal, TypeAlias, cast
+
+"""<p>The log level for application logs. Possible values: <code>TRACE</code>, <code>DEBUG</code>, <code>INFO</code>, <code>WARN</code>, <code>ERROR</code>, <code>FATAL</code>.</p>"""
+ApplicationLogLevel: TypeAlias = Literal[
+    "TRACE",
+    "DEBUG",
+    "INFO",
+    "WARN",
+    "ERROR",
+    "FATAL",
+]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ApplicationLogLevel) -> str:
+    return value
+
+
+def deserialize_json(data: str) -> ApplicationLogLevel:
+    return cast(ApplicationLogLevel, data)