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

capo_lambda_core/errors/network_connector_limit_exceeded_exception.py

@@ -0,0 +1,60 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdacore#NetworkConnectorLimitExceededException``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_lambda_core.errors import ServiceError
+
+if TYPE_CHECKING:
+    import capo_lambda_core.types.string
+
+
+class NetworkConnectorLimitExceededException_(TypedDict, closed=True):
+    type: NotRequired["capo_lambda_core.types.string.String"]
+    """<p>The exception type.</p>"""
+    message: NotRequired["capo_lambda_core.types.string.String"]
+    """<p>A human-readable description of the error.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: NetworkConnectorLimitExceededException_) -> 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) -> NetworkConnectorLimitExceededException_:
+    out: NetworkConnectorLimitExceededException_ = {}  # 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 NetworkConnectorLimitExceededException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.lambdacore#NetworkConnectorLimitExceededException``."""
+
+    code: str | None = "NetworkConnectorLimitExceededException"
+
+    def __init__(
+        self, data: NetworkConnectorLimitExceededException_, message: str | None = None
+    ):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="NetworkConnectorLimitExceededException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_json(
+        cls, data: dict, message: str | None = None
+    ) -> "NetworkConnectorLimitExceededException":
+        return cls(deserialize_json(data), message)

capo_lambda_core/errors/resource_conflict_exception.py

@@ -0,0 +1,57 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdacore#ResourceConflictException``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_lambda_core.errors import ServiceError
+
+if TYPE_CHECKING:
+    import capo_lambda_core.types.string
+
+
+class ResourceConflictException_(TypedDict, closed=True):
+    type: NotRequired["capo_lambda_core.types.string.String"]
+    """<p>The exception type.</p>"""
+    message: NotRequired["capo_lambda_core.types.string.String"]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ResourceConflictException_) -> 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) -> ResourceConflictException_:
+    out: ResourceConflictException_ = {}  # 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 ResourceConflictException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.lambdacore#ResourceConflictException``."""
+
+    code: str | None = "ResourceConflictException"
+
+    def __init__(self, data: ResourceConflictException_, message: str | None = None):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="ResourceConflictException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_json(
+        cls, data: dict, message: str | None = None
+    ) -> "ResourceConflictException":
+        return cls(deserialize_json(data), message)

capo_lambda_core/errors/resource_not_found_exception.py

@@ -0,0 +1,57 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdacore#ResourceNotFoundException``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_lambda_core.errors import ServiceError
+
+if TYPE_CHECKING:
+    import capo_lambda_core.types.string
+
+
+class ResourceNotFoundException_(TypedDict, closed=True):
+    type: NotRequired["capo_lambda_core.types.string.String"]
+    """<p>The exception type.</p>"""
+    message: NotRequired["capo_lambda_core.types.string.String"]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ResourceNotFoundException_) -> 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) -> ResourceNotFoundException_:
+    out: ResourceNotFoundException_ = {}  # 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 ResourceNotFoundException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.lambdacore#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_core/errors/service_exception.py

@@ -0,0 +1,55 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdacore#ServiceException``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_lambda_core.errors import ServiceError
+
+if TYPE_CHECKING:
+    import capo_lambda_core.types.string
+
+
+class ServiceException_(TypedDict, closed=True):
+    type: NotRequired["capo_lambda_core.types.string.String"]
+    """<p>The exception type.</p>"""
+    message: NotRequired["capo_lambda_core.types.string.String"]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ServiceException_) -> 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) -> ServiceException_:
+    out: ServiceException_ = {}  # 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 ServiceException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.lambdacore#ServiceException``."""
+
+    code: str | None = "ServiceException"
+
+    def __init__(self, data: ServiceException_, message: str | None = None):
+        super().__init__(
+            "server",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="ServiceException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_json(cls, data: dict, message: str | None = None) -> "ServiceException":
+        return cls(deserialize_json(data), message)

capo_lambda_core/errors/too_many_requests_exception.py

@@ -0,0 +1,74 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdacore#TooManyRequestsException``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_lambda_core.errors import ServiceError
+
+if TYPE_CHECKING:
+    import capo_lambda_core.types.string
+    import capo_lambda_core.types.throttle_reason
+
+
+class TooManyRequestsException_(TypedDict, closed=True):
+    retry_after_seconds: NotRequired["capo_lambda_core.types.string.String"]
+    """<p>The number of seconds to wait before retrying the request.</p>"""
+    type: NotRequired["capo_lambda_core.types.string.String"]
+    """<p>The exception type.</p>"""
+    message: NotRequired["capo_lambda_core.types.string.String"]
+    reason: NotRequired["capo_lambda_core.types.throttle_reason.ThrottleReason"]
+    """<p>The reason for the throttling.</p>"""
+
+
+# --- 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"]
+    if "reason" in value:
+        import capo_lambda_core.types.throttle_reason
+
+        out["Reason"] = capo_lambda_core.types.throttle_reason.serialize_json(
+            value["reason"]
+        )
+    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"]
+    if data.get("Reason") is not None:
+        import capo_lambda_core.types.throttle_reason
+
+        out["reason"] = capo_lambda_core.types.throttle_reason.deserialize_json(
+            data["Reason"]
+        )
+    return out
+
+
+class TooManyRequestsException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.lambdacore#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_core/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_core/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_core/types/associated_compute_resource_types_list.py

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

capo_lambda_core/types/client_token_string.py

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

capo_lambda_core/types/compute_resource_type.py

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

capo_lambda_core/types/core_timestamp.py

@@ -0,0 +1,20 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdacore#CoreTimestamp``."""
+
+import datetime
+from typing import TypeAlias
+
+CoreTimestamp: TypeAlias = datetime.datetime
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: CoreTimestamp) -> str:
+    value = (
+        value.astimezone(datetime.timezone.utc)
+        if value.tzinfo
+        else value.replace(tzinfo=datetime.timezone.utc)
+    )
+    return value.isoformat().replace("+00:00", "Z")
+
+
+def deserialize_json(data: str) -> CoreTimestamp:
+    return datetime.datetime.fromisoformat(data.replace("Z", "+00:00"))

capo_lambda_core/types/create_network_connector_request.py

@@ -0,0 +1,88 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdacore#CreateNetworkConnectorRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_lambda_core.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_lambda_core.types.client_token_string
+    import capo_lambda_core.types.network_connector_configuration
+    import capo_lambda_core.types.network_connector_name
+    import capo_lambda_core.types.network_connector_role_arn
+    import capo_lambda_core.types.network_connector_tags
+
+
+class CreateNetworkConnectorRequest(TypedDict, closed=True):
+    name: "capo_lambda_core.types.network_connector_name.NetworkConnectorName"
+    """<p>A unique name for the network connector within your account and Region. You can use the name to identify the connector in subsequent API calls.</p>"""
+    configuration: "capo_lambda_core.types.network_connector_configuration.NetworkConnectorConfiguration"
+    """<p>The network configuration for the connector. Specify a <code>VpcEgressConfiguration</code> to enable outbound traffic routing through your VPC.</p>"""
+    operator_role: NotRequired[
+        "capo_lambda_core.types.network_connector_role_arn.NetworkConnectorRoleArn"
+    ]
+    """<p>The ARN of the IAM role that Lambda assumes to manage elastic network interfaces in your VPC. This role must have permissions for <code>ec2:CreateNetworkInterface</code>, <code>ec2:DeleteNetworkInterface</code>, and related describe operations.</p>"""
+    client_token: NotRequired[
+        "capo_lambda_core.types.client_token_string.ClientTokenString"
+    ]
+    """<p>A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If you retry a request with the same client token, the API returns the existing connector without creating a duplicate.</p>"""
+    tags: NotRequired[
+        "capo_lambda_core.types.network_connector_tags.NetworkConnectorTags"
+    ]
+    """<p>A map of key-value pairs to associate with the network connector for organization, cost allocation, or access control.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: CreateNetworkConnectorRequest) -> dict:
+    out: dict = {}
+    out["Name"] = value["name"]
+    import capo_lambda_core.types.network_connector_configuration
+
+    out["Configuration"] = (
+        capo_lambda_core.types.network_connector_configuration.serialize_json(
+            value["configuration"]
+        )
+    )
+    if "operator_role" in value:
+        out["OperatorRole"] = value["operator_role"]
+    if "client_token" in value:
+        out["ClientToken"] = value["client_token"]
+    if "tags" in value:
+        import capo_lambda_core.types.network_connector_tags
+
+        out["Tags"] = capo_lambda_core.types.network_connector_tags.serialize_json(
+            value["tags"]
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> CreateNetworkConnectorRequest:
+    out: CreateNetworkConnectorRequest = {}  # type: ignore[typeddict-item]
+    if data.get("Name") is not None:
+        out["name"] = data["Name"]
+    else:
+        raise DeserializationError("CreateNetworkConnectorRequest.name required")
+    if data.get("Configuration") is not None:
+        import capo_lambda_core.types.network_connector_configuration
+
+        out["configuration"] = (
+            capo_lambda_core.types.network_connector_configuration.deserialize_json(
+                data["Configuration"]
+            )
+        )
+    else:
+        raise DeserializationError(
+            "CreateNetworkConnectorRequest.configuration required"
+        )
+    if data.get("OperatorRole") is not None:
+        out["operator_role"] = data["OperatorRole"]
+    if data.get("ClientToken") is not None:
+        out["client_token"] = data["ClientToken"]
+    if data.get("Tags") is not None:
+        import capo_lambda_core.types.network_connector_tags
+
+        out["tags"] = capo_lambda_core.types.network_connector_tags.deserialize_json(
+            data["Tags"]
+        )
+    return out

capo_lambda_core/types/create_network_connector_response.py

@@ -0,0 +1,93 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdacore#CreateNetworkConnectorResponse``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_lambda_core.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_lambda_core.types.network_connector_arn
+    import capo_lambda_core.types.network_connector_configuration
+    import capo_lambda_core.types.network_connector_id
+    import capo_lambda_core.types.network_connector_name
+    import capo_lambda_core.types.network_connector_role_arn
+    import capo_lambda_core.types.network_connector_state
+
+
+class CreateNetworkConnectorResponse(TypedDict, closed=True):
+    arn: "capo_lambda_core.types.network_connector_arn.NetworkConnectorArn"
+    """<p>The Amazon Resource Name (ARN) of the network connector.</p>"""
+    name: "capo_lambda_core.types.network_connector_name.NetworkConnectorName"
+    """<p>The name of the network connector.</p>"""
+    id: "capo_lambda_core.types.network_connector_id.NetworkConnectorId"
+    configuration: NotRequired[
+        "capo_lambda_core.types.network_connector_configuration.NetworkConnectorConfiguration"
+    ]
+    """<p>The network configuration of the connector, including VPC subnets and security groups.</p>"""
+    operator_role: NotRequired[
+        "capo_lambda_core.types.network_connector_role_arn.NetworkConnectorRoleArn"
+    ]
+    """<p>The ARN of the IAM role that Lambda uses to manage the underlying ENI resources for this connector.</p>"""
+    state: NotRequired[
+        "capo_lambda_core.types.network_connector_state.NetworkConnectorState"
+    ]
+    """<p>The current state of the network connector.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: CreateNetworkConnectorResponse) -> dict:
+    out: dict = {}
+    out["Arn"] = value["arn"]
+    out["Name"] = value["name"]
+    out["Id"] = value["id"]
+    if "configuration" in value:
+        import capo_lambda_core.types.network_connector_configuration
+
+        out["Configuration"] = (
+            capo_lambda_core.types.network_connector_configuration.serialize_json(
+                value["configuration"]
+            )
+        )
+    if "operator_role" in value:
+        out["OperatorRole"] = value["operator_role"]
+    if "state" in value:
+        import capo_lambda_core.types.network_connector_state
+
+        out["State"] = capo_lambda_core.types.network_connector_state.serialize_json(
+            value["state"]
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> CreateNetworkConnectorResponse:
+    out: CreateNetworkConnectorResponse = {}  # type: ignore[typeddict-item]
+    if data.get("Arn") is not None:
+        out["arn"] = data["Arn"]
+    else:
+        raise DeserializationError("CreateNetworkConnectorResponse.arn required")
+    if data.get("Name") is not None:
+        out["name"] = data["Name"]
+    else:
+        raise DeserializationError("CreateNetworkConnectorResponse.name required")
+    if data.get("Id") is not None:
+        out["id"] = data["Id"]
+    else:
+        raise DeserializationError("CreateNetworkConnectorResponse.id required")
+    if data.get("Configuration") is not None:
+        import capo_lambda_core.types.network_connector_configuration
+
+        out["configuration"] = (
+            capo_lambda_core.types.network_connector_configuration.deserialize_json(
+                data["Configuration"]
+            )
+        )
+    if data.get("OperatorRole") is not None:
+        out["operator_role"] = data["OperatorRole"]
+    if data.get("State") is not None:
+        import capo_lambda_core.types.network_connector_state
+
+        out["state"] = capo_lambda_core.types.network_connector_state.deserialize_json(
+            data["State"]
+        )
+    return out

capo_lambda_core/types/delete_network_connector_request.py

@@ -0,0 +1,25 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdacore#DeleteNetworkConnectorRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda_core.types.network_connector_identifier
+
+
+class DeleteNetworkConnectorRequest(TypedDict, closed=True):
+    identifier: (
+        "capo_lambda_core.types.network_connector_identifier.NetworkConnectorIdentifier"
+    )
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: DeleteNetworkConnectorRequest) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> DeleteNetworkConnectorRequest:
+    out: DeleteNetworkConnectorRequest = {}  # type: ignore[typeddict-item]
+    return out