capo-lambda-microvms 0.1.0__py3-none-any.whl

capo_lambda_microvms/errors/throttling_exception.py

@@ -0,0 +1,58 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdamicrovms#ThrottlingException``."""
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_lambda_microvms.errors import ServiceError
+
+
+class ThrottlingException_(TypedDict, closed=True):
+    message: NotRequired["str"]
+    service_code: NotRequired["str"]
+    """<p>The service code of the throttled service quota.</p>"""
+    quota_code: NotRequired["str"]
+    """<p>The quota code of the throttled service quota.</p>"""
+    retry_after_seconds: NotRequired["int"]
+    """<p>The number of seconds to wait before retrying the request.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ThrottlingException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        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"]
+    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.lambdamicrovms#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_microvms/errors/too_many_requests_exception.py

@@ -0,0 +1,52 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdamicrovms#TooManyRequestsException``."""
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_lambda_microvms.errors import ServiceError
+
+
+class TooManyRequestsException_(TypedDict, closed=True):
+    type: NotRequired["str"]
+    """<p>The exception type.</p>"""
+    message: NotRequired["str"]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: TooManyRequestsException_) -> dict:
+    out: dict = {}
+    if "type" in value:
+        out["Type"] = value["type"]
+    if "message" in value:
+        out["message"] = value["message"]
+    return out
+
+
+def deserialize_json(data: dict) -> TooManyRequestsException_:
+    out: TooManyRequestsException_ = {}  # type: ignore[typeddict-item]
+    if data.get("Type") is not None:
+        out["type"] = data["Type"]
+    if data.get("message") is not None:
+        out["message"] = data["message"]
+    return out
+
+
+class TooManyRequestsException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.lambdamicrovms#TooManyRequestsException``."""
+
+    code: str | None = "TooManyRequestsException"
+
+    def __init__(self, data: TooManyRequestsException_, message: str | None = None):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="TooManyRequestsException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_json(
+        cls, data: dict, message: str | None = None
+    ) -> "TooManyRequestsException":
+        return cls(deserialize_json(data), message)

capo_lambda_microvms/errors/validation_exception.py

@@ -0,0 +1,44 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdamicrovms#ValidationException``."""
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_lambda_microvms.errors import ServiceError
+
+
+class ValidationException_(TypedDict, closed=True):
+    message: NotRequired["str"]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ValidationException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        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"]
+    return out
+
+
+class ValidationException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.lambdamicrovms#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_microvms/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_microvms/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_microvms/types/architecture.py

@@ -0,0 +1,14 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdamicrovms#Architecture``."""
+
+from typing import Literal, TypeAlias, cast
+
+Architecture: TypeAlias = Literal["ARM_64",]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: Architecture) -> str:
+    return value
+
+
+def deserialize_json(data: str) -> Architecture:
+    return cast(Architecture, data)

capo_lambda_microvms/types/auth_token_key.py

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

capo_lambda_microvms/types/auth_token_value.py

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

capo_lambda_microvms/types/build_state.py

@@ -0,0 +1,19 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdamicrovms#BuildState``."""
+
+from typing import Literal, TypeAlias, cast
+
+BuildState: TypeAlias = Literal[
+    "PENDING",
+    "IN_PROGRESS",
+    "SUCCESSFUL",
+    "FAILED",
+]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: BuildState) -> str:
+    return value
+
+
+def deserialize_json(data: str) -> BuildState:
+    return cast(BuildState, data)

capo_lambda_microvms/types/capability.py

@@ -0,0 +1,15 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdamicrovms#Capability``."""
+
+from typing import Literal, TypeAlias, cast
+
+"""Capability granted to the application when booted"""
+Capability: TypeAlias = Literal["ALL",]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: Capability) -> str:
+    return value
+
+
+def deserialize_json(data: str) -> Capability:
+    return cast(Capability, data)

capo_lambda_microvms/types/capability_list.py

@@ -0,0 +1,29 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdamicrovms#CapabilityList``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+if TYPE_CHECKING:
+    import capo_lambda_microvms.types.capability
+
+CapabilityList: TypeAlias = list["capo_lambda_microvms.types.capability.Capability"]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: CapabilityList) -> list:
+    import capo_lambda_microvms.types.capability
+
+    out: list = []
+    for item in value:
+        out.append(capo_lambda_microvms.types.capability.serialize_json(item))
+    return out
+
+
+def deserialize_json(data: list) -> CapabilityList:
+    import capo_lambda_microvms.types.capability
+
+    out: CapabilityList = []
+    for item in data:
+        if item is None:
+            continue
+        out.append(capo_lambda_microvms.types.capability.deserialize_json(item))
+    return out

capo_lambda_microvms/types/chipset.py

@@ -0,0 +1,14 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdamicrovms#Chipset``."""
+
+from typing import Literal, TypeAlias, cast
+
+Chipset: TypeAlias = Literal["GRAVITON",]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: Chipset) -> str:
+    return value
+
+
+def deserialize_json(data: str) -> Chipset:
+    return cast(Chipset, data)

capo_lambda_microvms/types/cloud_watch_logging.py

@@ -0,0 +1,34 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdamicrovms#CloudWatchLogging``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda_microvms.types.string
+
+
+class CloudWatchLogging(TypedDict, closed=True):
+    log_group: NotRequired["capo_lambda_microvms.types.string.String"]
+    """<p>The name of the CloudWatch Logs log group to send logs to.</p>"""
+    log_stream: NotRequired["capo_lambda_microvms.types.string.String"]
+    """<p>The name of the CloudWatch Logs log stream within the log group.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: CloudWatchLogging) -> dict:
+    out: dict = {}
+    if "log_group" in value:
+        out["logGroup"] = value["log_group"]
+    if "log_stream" in value:
+        out["logStream"] = value["log_stream"]
+    return out
+
+
+def deserialize_json(data: dict) -> CloudWatchLogging:
+    out: CloudWatchLogging = {}  # type: ignore[typeddict-item]
+    if data.get("logGroup") is not None:
+        out["log_group"] = data["logGroup"]
+    if data.get("logStream") is not None:
+        out["log_stream"] = data["logStream"]
+    return out

capo_lambda_microvms/types/code_artifact.py

@@ -0,0 +1,32 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdamicrovms#CodeArtifact``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+from typing_extensions import TypedDict
+
+from capo_lambda_microvms.errors import DeserializationError, SerializationError
+
+if TYPE_CHECKING:
+    import capo_lambda_microvms.types.non_blank_string
+
+
+class _CodeArtifact_uri(TypedDict, closed=True):
+    uri: "capo_lambda_microvms.types.non_blank_string.NonBlankString"
+
+
+CodeArtifact: TypeAlias = _CodeArtifact_uri
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: CodeArtifact) -> dict:
+    if "uri" in value:
+        return {"uri": value["uri"]}
+    else:
+        raise SerializationError("CodeArtifact: no variant present")
+
+
+def deserialize_json(data: dict) -> CodeArtifact:
+    if data.get("uri") is not None:
+        return {"uri": data["uri"]}
+    else:
+        raise DeserializationError("CodeArtifact: no recognized variant key")

capo_lambda_microvms/types/cpu_configuration.py

@@ -0,0 +1,39 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdamicrovms#CpuConfiguration``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_lambda_microvms.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_lambda_microvms.types.architecture
+
+
+class CpuConfiguration(TypedDict, closed=True):
+    architecture: "capo_lambda_microvms.types.architecture.Architecture"
+    """<p>The CPU architecture.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: CpuConfiguration) -> dict:
+    out: dict = {}
+    import capo_lambda_microvms.types.architecture
+
+    out["architecture"] = capo_lambda_microvms.types.architecture.serialize_json(
+        value["architecture"]
+    )
+    return out
+
+
+def deserialize_json(data: dict) -> CpuConfiguration:
+    out: CpuConfiguration = {}  # type: ignore[typeddict-item]
+    if data.get("architecture") is not None:
+        import capo_lambda_microvms.types.architecture
+
+        out["architecture"] = capo_lambda_microvms.types.architecture.deserialize_json(
+            data["architecture"]
+        )
+    else:
+        raise DeserializationError("CpuConfiguration.architecture required")
+    return out

capo_lambda_microvms/types/cpu_configuration_list.py

@@ -0,0 +1,31 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdamicrovms#CpuConfigurationList``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+if TYPE_CHECKING:
+    import capo_lambda_microvms.types.cpu_configuration
+
+CpuConfigurationList: TypeAlias = list[
+    "capo_lambda_microvms.types.cpu_configuration.CpuConfiguration"
+]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: CpuConfigurationList) -> list:
+    import capo_lambda_microvms.types.cpu_configuration
+
+    out: list = []
+    for item in value:
+        out.append(capo_lambda_microvms.types.cpu_configuration.serialize_json(item))
+    return out
+
+
+def deserialize_json(data: list) -> CpuConfigurationList:
+    import capo_lambda_microvms.types.cpu_configuration
+
+    out: CpuConfigurationList = []
+    for item in data:
+        if item is None:
+            continue
+        out.append(capo_lambda_microvms.types.cpu_configuration.deserialize_json(item))
+    return out

capo_lambda_microvms/types/create_microvm_auth_token_request.py

@@ -0,0 +1,62 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdamicrovms#CreateMicrovmAuthTokenRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_lambda_microvms.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_lambda_microvms.types.list_of_port_specification
+    import capo_lambda_microvms.types.microvm_identifier
+    import capo_lambda_microvms.types.positive_integer
+
+
+class CreateMicrovmAuthTokenRequest(TypedDict, closed=True):
+    microvm_identifier: (
+        "capo_lambda_microvms.types.microvm_identifier.MicrovmIdentifier"
+    )
+    """<p>The ID of the MicroVM to create an authentication token for.</p>"""
+    expiration_in_minutes: "capo_lambda_microvms.types.positive_integer.PositiveInteger"
+    """<p>The duration in minutes before the authentication token expires. Maximum: 60 minutes.</p>"""
+    allowed_ports: (
+        "capo_lambda_microvms.types.list_of_port_specification.ListOfPortSpecification"
+    )
+    """<p>The list of port specifications that the authentication token grants access to on the MicroVM.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: CreateMicrovmAuthTokenRequest) -> dict:
+    out: dict = {}
+    out["expirationInMinutes"] = value["expiration_in_minutes"]
+    import capo_lambda_microvms.types.list_of_port_specification
+
+    out["allowedPorts"] = (
+        capo_lambda_microvms.types.list_of_port_specification.serialize_json(
+            value["allowed_ports"]
+        )
+    )
+    return out
+
+
+def deserialize_json(data: dict) -> CreateMicrovmAuthTokenRequest:
+    out: CreateMicrovmAuthTokenRequest = {}  # type: ignore[typeddict-item]
+    if data.get("expirationInMinutes") is not None:
+        out["expiration_in_minutes"] = data["expirationInMinutes"]
+    else:
+        raise DeserializationError(
+            "CreateMicrovmAuthTokenRequest.expiration_in_minutes required"
+        )
+    if data.get("allowedPorts") is not None:
+        import capo_lambda_microvms.types.list_of_port_specification
+
+        out["allowed_ports"] = (
+            capo_lambda_microvms.types.list_of_port_specification.deserialize_json(
+                data["allowedPorts"]
+            )
+        )
+    else:
+        raise DeserializationError(
+            "CreateMicrovmAuthTokenRequest.allowed_ports required"
+        )
+    return out

capo_lambda_microvms/types/create_microvm_auth_token_response.py

@@ -0,0 +1,39 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdamicrovms#CreateMicrovmAuthTokenResponse``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_lambda_microvms.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_lambda_microvms.types.token_parts
+
+
+class CreateMicrovmAuthTokenResponse(TypedDict, closed=True):
+    auth_token: "capo_lambda_microvms.types.token_parts.TokenParts"
+    r"""<p>A map containing the authentication token. Use the value at key \"X-aws-proxy-auth\" as the header value when connecting to the MicroVM endpoint.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: CreateMicrovmAuthTokenResponse) -> dict:
+    out: dict = {}
+    import capo_lambda_microvms.types.token_parts
+
+    out["authToken"] = capo_lambda_microvms.types.token_parts.serialize_json(
+        value["auth_token"]
+    )
+    return out
+
+
+def deserialize_json(data: dict) -> CreateMicrovmAuthTokenResponse:
+    out: CreateMicrovmAuthTokenResponse = {}  # type: ignore[typeddict-item]
+    if data.get("authToken") is not None:
+        import capo_lambda_microvms.types.token_parts
+
+        out["auth_token"] = capo_lambda_microvms.types.token_parts.deserialize_json(
+            data["authToken"]
+        )
+    else:
+        raise DeserializationError("CreateMicrovmAuthTokenResponse.auth_token required")
+    return out