capo-lambda 0.5.0__py3-none-any.whl

capo_lambda/types/alias_configuration.py

@@ -0,0 +1,77 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#AliasConfiguration``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.alias
+    import capo_lambda.types.alias_routing_configuration
+    import capo_lambda.types.description
+    import capo_lambda.types.function_arn
+    import capo_lambda.types.string
+    import capo_lambda.types.version
+
+
+class AliasConfiguration(TypedDict, closed=True):
+    alias_arn: NotRequired["capo_lambda.types.function_arn.FunctionArn"]
+    """<p>The Amazon Resource Name (ARN) of the alias.</p>"""
+    name: NotRequired["capo_lambda.types.alias.Alias"]
+    """<p>The name of the alias.</p>"""
+    function_version: NotRequired["capo_lambda.types.version.Version"]
+    """<p>The function version that the alias invokes.</p>"""
+    description: NotRequired["capo_lambda.types.description.Description"]
+    """<p>A description of the alias.</p>"""
+    routing_config: NotRequired[
+        "capo_lambda.types.alias_routing_configuration.AliasRoutingConfiguration"
+    ]
+    r"""<p>The <a href=\"https://docs.aws.amazon.com/lambda/latest/dg/lambda-traffic-shifting-using-aliases.html\">routing configuration</a> of the alias.</p>"""
+    revision_id: NotRequired["capo_lambda.types.string.String"]
+    """<p>A unique identifier that changes when you update the alias.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: AliasConfiguration) -> dict:
+    out: dict = {}
+    if "alias_arn" in value:
+        out["AliasArn"] = value["alias_arn"]
+    if "name" in value:
+        out["Name"] = value["name"]
+    if "function_version" in value:
+        out["FunctionVersion"] = value["function_version"]
+    if "description" in value:
+        out["Description"] = value["description"]
+    if "routing_config" in value:
+        import capo_lambda.types.alias_routing_configuration
+
+        out["RoutingConfig"] = (
+            capo_lambda.types.alias_routing_configuration.serialize_json(
+                value["routing_config"]
+            )
+        )
+    if "revision_id" in value:
+        out["RevisionId"] = value["revision_id"]
+    return out
+
+
+def deserialize_json(data: dict) -> AliasConfiguration:
+    out: AliasConfiguration = {}  # type: ignore[typeddict-item]
+    if "AliasArn" in data:
+        out["alias_arn"] = data["AliasArn"]
+    if "Name" in data:
+        out["name"] = data["Name"]
+    if "FunctionVersion" in data:
+        out["function_version"] = data["FunctionVersion"]
+    if "Description" in data:
+        out["description"] = data["Description"]
+    if "RoutingConfig" in data:
+        import capo_lambda.types.alias_routing_configuration
+
+        out["routing_config"] = (
+            capo_lambda.types.alias_routing_configuration.deserialize_json(
+                data["RoutingConfig"]
+            )
+        )
+    if "RevisionId" in data:
+        out["revision_id"] = data["RevisionId"]
+    return out

capo_lambda/types/alias_list.py

@@ -0,0 +1,27 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#AliasList``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+if TYPE_CHECKING:
+    import capo_lambda.types.alias_configuration
+
+AliasList: TypeAlias = list["capo_lambda.types.alias_configuration.AliasConfiguration"]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: AliasList) -> list:
+    import capo_lambda.types.alias_configuration
+
+    out: list = []
+    for item in value:
+        out.append(capo_lambda.types.alias_configuration.serialize_json(item))
+    return out
+
+
+def deserialize_json(data: list) -> AliasList:
+    import capo_lambda.types.alias_configuration
+
+    out: AliasList = []
+    for item in data:
+        out.append(capo_lambda.types.alias_configuration.deserialize_json(item))
+    return out

capo_lambda/types/alias_routing_configuration.py

@@ -0,0 +1,42 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#AliasRoutingConfiguration``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.additional_version_weights
+
+
+class AliasRoutingConfiguration(TypedDict, closed=True):
+    additional_version_weights: NotRequired[
+        "capo_lambda.types.additional_version_weights.AdditionalVersionWeights"
+    ]
+    """<p>The second version, and the percentage of traffic that's routed to it.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: AliasRoutingConfiguration) -> dict:
+    out: dict = {}
+    if "additional_version_weights" in value:
+        import capo_lambda.types.additional_version_weights
+
+        out["AdditionalVersionWeights"] = (
+            capo_lambda.types.additional_version_weights.serialize_json(
+                value["additional_version_weights"]
+            )
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> AliasRoutingConfiguration:
+    out: AliasRoutingConfiguration = {}  # type: ignore[typeddict-item]
+    if "AdditionalVersionWeights" in data:
+        import capo_lambda.types.additional_version_weights
+
+        out["additional_version_weights"] = (
+            capo_lambda.types.additional_version_weights.deserialize_json(
+                data["AdditionalVersionWeights"]
+            )
+        )
+    return out

capo_lambda/types/allow_credentials.py

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

capo_lambda/types/allow_methods_list.py

@@ -0,0 +1,17 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#AllowMethodsList``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+if TYPE_CHECKING:
+    import capo_lambda.types.method
+
+AllowMethodsList: TypeAlias = list["capo_lambda.types.method.Method"]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: AllowMethodsList) -> list:
+    return list(value)
+
+
+def deserialize_json(data: list) -> AllowMethodsList:
+    return list(data)

capo_lambda/types/allow_origins_list.py

@@ -0,0 +1,17 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#AllowOriginsList``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+if TYPE_CHECKING:
+    import capo_lambda.types.origin
+
+AllowOriginsList: TypeAlias = list["capo_lambda.types.origin.Origin"]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: AllowOriginsList) -> list:
+    return list(value)
+
+
+def deserialize_json(data: list) -> AllowOriginsList:
+    return list(data)

capo_lambda/types/allowed_publishers.py

@@ -0,0 +1,47 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#AllowedPublishers``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_lambda.types.signing_profile_version_arns
+
+
+class AllowedPublishers(TypedDict, closed=True):
+    signing_profile_version_arns: (
+        "capo_lambda.types.signing_profile_version_arns.SigningProfileVersionArns"
+    )
+    """<p>The Amazon Resource Name (ARN) for each of the signing profiles. A signing profile defines a trusted user who can sign a code package. </p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: AllowedPublishers) -> dict:
+    out: dict = {}
+    import capo_lambda.types.signing_profile_version_arns
+
+    out["SigningProfileVersionArns"] = (
+        capo_lambda.types.signing_profile_version_arns.serialize_json(
+            value["signing_profile_version_arns"]
+        )
+    )
+    return out
+
+
+def deserialize_json(data: dict) -> AllowedPublishers:
+    out: AllowedPublishers = {}  # type: ignore[typeddict-item]
+    if "SigningProfileVersionArns" in data:
+        import capo_lambda.types.signing_profile_version_arns
+
+        out["signing_profile_version_arns"] = (
+            capo_lambda.types.signing_profile_version_arns.deserialize_json(
+                data["SigningProfileVersionArns"]
+            )
+        )
+    else:
+        raise DeserializationError(
+            "AllowedPublishers.signing_profile_version_arns required"
+        )
+    return out

capo_lambda/types/amazon_managed_kafka_event_source_config.py

@@ -0,0 +1,49 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#AmazonManagedKafkaEventSourceConfig``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.kafka_schema_registry_config
+    import capo_lambda.types.uri
+
+
+class AmazonManagedKafkaEventSourceConfig(TypedDict, closed=True):
+    consumer_group_id: NotRequired["capo_lambda.types.uri.URI"]
+    r"""<p>The identifier for the Kafka consumer group to join. The consumer group ID must be unique among all your Kafka event sources. After creating a Kafka event source mapping with the consumer group ID specified, you cannot update this value. For more information, see <a href=\"https://docs.aws.amazon.com/lambda/latest/dg/with-msk.html#services-msk-consumer-group-id\">Customizable consumer group ID</a>.</p>"""
+    schema_registry_config: NotRequired[
+        "capo_lambda.types.kafka_schema_registry_config.KafkaSchemaRegistryConfig"
+    ]
+    """<p>Specific configuration settings for a Kafka schema registry.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: AmazonManagedKafkaEventSourceConfig) -> dict:
+    out: dict = {}
+    if "consumer_group_id" in value:
+        out["ConsumerGroupId"] = value["consumer_group_id"]
+    if "schema_registry_config" in value:
+        import capo_lambda.types.kafka_schema_registry_config
+
+        out["SchemaRegistryConfig"] = (
+            capo_lambda.types.kafka_schema_registry_config.serialize_json(
+                value["schema_registry_config"]
+            )
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> AmazonManagedKafkaEventSourceConfig:
+    out: AmazonManagedKafkaEventSourceConfig = {}  # type: ignore[typeddict-item]
+    if "ConsumerGroupId" in data:
+        out["consumer_group_id"] = data["ConsumerGroupId"]
+    if "SchemaRegistryConfig" in data:
+        import capo_lambda.types.kafka_schema_registry_config
+
+        out["schema_registry_config"] = (
+            capo_lambda.types.kafka_schema_registry_config.deserialize_json(
+                data["SchemaRegistryConfig"]
+            )
+        )
+    return out

capo_lambda/types/application_log_level.py

@@ -0,0 +1,21 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#ApplicationLogLevel``."""
+
+from typing import Literal, TypeAlias, cast
+
+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)

capo_lambda/types/architecture.py

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

capo_lambda/types/architectures_list.py

@@ -0,0 +1,27 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#ArchitecturesList``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+if TYPE_CHECKING:
+    import capo_lambda.types.architecture
+
+ArchitecturesList: TypeAlias = list["capo_lambda.types.architecture.Architecture"]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ArchitecturesList) -> list:
+    import capo_lambda.types.architecture
+
+    out: list = []
+    for item in value:
+        out.append(capo_lambda.types.architecture.serialize_json(item))
+    return out
+
+
+def deserialize_json(data: list) -> ArchitecturesList:
+    import capo_lambda.types.architecture
+
+    out: ArchitecturesList = []
+    for item in data:
+        out.append(capo_lambda.types.architecture.deserialize_json(item))
+    return out

capo_lambda/types/arn.py

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

capo_lambda/types/attempt_count.py

@@ -0,0 +1,5 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#AttemptCount``."""
+
+from typing import TypeAlias
+
+AttemptCount: TypeAlias = int

capo_lambda/types/batch_size.py

@@ -0,0 +1,5 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#BatchSize``."""
+
+from typing import TypeAlias
+
+BatchSize: TypeAlias = int

capo_lambda/types/binary_operation_payload.py

@@ -0,0 +1,15 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#BinaryOperationPayload``."""
+
+import base64
+from typing import TypeAlias
+
+BinaryOperationPayload: TypeAlias = bytes
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: BinaryOperationPayload) -> str:
+    return base64.b64encode(value).decode("ascii")
+
+
+def deserialize_json(data: str) -> BinaryOperationPayload:
+    return base64.b64decode(data)

capo_lambda/types/bisect_batch_on_function_error.py

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

capo_lambda/types/blob.py

@@ -0,0 +1,15 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#Blob``."""
+
+import base64
+from typing import TypeAlias
+
+Blob: TypeAlias = bytes
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: Blob) -> str:
+    return base64.b64encode(value).decode("ascii")
+
+
+def deserialize_json(data: str) -> Blob:
+    return base64.b64decode(data)

capo_lambda/types/blob_stream.py

@@ -0,0 +1,7 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#BlobStream``."""
+
+from typing import TypeAlias
+
+from capo_lambda._iter import AnyIterator
+
+BlobStream: TypeAlias = AnyIterator[bytes]

capo_lambda/types/boolean.py

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

capo_lambda/types/callback_details.py

@@ -0,0 +1,46 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#CallbackDetails``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.callback_id
+    import capo_lambda.types.error_object
+    import capo_lambda.types.operation_payload
+
+
+class CallbackDetails(TypedDict, closed=True):
+    callback_id: NotRequired["capo_lambda.types.callback_id.CallbackId"]
+    """<p>The callback ID. Callback IDs are generated by the <code>DurableContext</code> when a durable function calls <code>ctx.waitForCallback</code>.</p>"""
+    result: NotRequired["capo_lambda.types.operation_payload.OperationPayload"]
+    """<p>The response payload from the callback operation as a string.</p>"""
+    error: NotRequired["capo_lambda.types.error_object.ErrorObject"]
+    """<p>An error object that contains details about the failure.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: CallbackDetails) -> dict:
+    out: dict = {}
+    if "callback_id" in value:
+        out["CallbackId"] = value["callback_id"]
+    if "result" in value:
+        out["Result"] = value["result"]
+    if "error" in value:
+        import capo_lambda.types.error_object
+
+        out["Error"] = capo_lambda.types.error_object.serialize_json(value["error"])
+    return out
+
+
+def deserialize_json(data: dict) -> CallbackDetails:
+    out: CallbackDetails = {}  # type: ignore[typeddict-item]
+    if "CallbackId" in data:
+        out["callback_id"] = data["CallbackId"]
+    if "Result" in data:
+        out["result"] = data["Result"]
+    if "Error" in data:
+        import capo_lambda.types.error_object
+
+        out["error"] = capo_lambda.types.error_object.deserialize_json(data["Error"])
+    return out

capo_lambda/types/callback_failed_details.py

@@ -0,0 +1,35 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#CallbackFailedDetails``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_lambda.types.event_error
+
+
+class CallbackFailedDetails(TypedDict, closed=True):
+    error: "capo_lambda.types.event_error.EventError"
+    """<p>An error object that contains details about the failure.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: CallbackFailedDetails) -> dict:
+    out: dict = {}
+    import capo_lambda.types.event_error
+
+    out["Error"] = capo_lambda.types.event_error.serialize_json(value["error"])
+    return out
+
+
+def deserialize_json(data: dict) -> CallbackFailedDetails:
+    out: CallbackFailedDetails = {}  # type: ignore[typeddict-item]
+    if "Error" in data:
+        import capo_lambda.types.event_error
+
+        out["error"] = capo_lambda.types.event_error.deserialize_json(data["Error"])
+    else:
+        raise DeserializationError("CallbackFailedDetails.error required")
+    return out

capo_lambda/types/callback_id.py

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

capo_lambda/types/callback_options.py

@@ -0,0 +1,36 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#CallbackOptions``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.duration_seconds
+
+
+class CallbackOptions(TypedDict, closed=True):
+    timeout_seconds: "capo_lambda.types.duration_seconds.DurationSeconds"
+    """<p>The timeout for the callback operation in seconds. If not specified or set to 0, the callback has no timeout.</p>"""
+    heartbeat_timeout_seconds: "capo_lambda.types.duration_seconds.DurationSeconds"
+    """<p>The heartbeat timeout for the callback operation, in seconds. If not specified or set to 0, heartbeat timeout is disabled.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: CallbackOptions) -> dict:
+    out: dict = {}
+    out["TimeoutSeconds"] = value.get("timeout_seconds", 0)
+    out["HeartbeatTimeoutSeconds"] = value.get("heartbeat_timeout_seconds", 0)
+    return out
+
+
+def deserialize_json(data: dict) -> CallbackOptions:
+    out: CallbackOptions = {}  # type: ignore[typeddict-item]
+    if "TimeoutSeconds" in data:
+        out["timeout_seconds"] = data["TimeoutSeconds"]
+    else:
+        out["timeout_seconds"] = 0
+    if "HeartbeatTimeoutSeconds" in data:
+        out["heartbeat_timeout_seconds"] = data["HeartbeatTimeoutSeconds"]
+    else:
+        out["heartbeat_timeout_seconds"] = 0
+    return out

capo_lambda/types/callback_started_details.py

@@ -0,0 +1,44 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#CallbackStartedDetails``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_lambda.types.callback_id
+    import capo_lambda.types.duration_seconds
+
+
+class CallbackStartedDetails(TypedDict, closed=True):
+    callback_id: "capo_lambda.types.callback_id.CallbackId"
+    """<p>The callback ID. Callback IDs are generated by the <code>DurableContext</code> when a durable function calls <code>ctx.waitForCallback</code>.</p>"""
+    heartbeat_timeout: NotRequired["capo_lambda.types.duration_seconds.DurationSeconds"]
+    """<p>The heartbeat timeout value, in seconds.</p>"""
+    timeout: NotRequired["capo_lambda.types.duration_seconds.DurationSeconds"]
+    """<p>The timeout value, in seconds.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: CallbackStartedDetails) -> dict:
+    out: dict = {}
+    out["CallbackId"] = value["callback_id"]
+    if "heartbeat_timeout" in value:
+        out["HeartbeatTimeout"] = value["heartbeat_timeout"]
+    if "timeout" in value:
+        out["Timeout"] = value["timeout"]
+    return out
+
+
+def deserialize_json(data: dict) -> CallbackStartedDetails:
+    out: CallbackStartedDetails = {}  # type: ignore[typeddict-item]
+    if "CallbackId" in data:
+        out["callback_id"] = data["CallbackId"]
+    else:
+        raise DeserializationError("CallbackStartedDetails.callback_id required")
+    if "HeartbeatTimeout" in data:
+        out["heartbeat_timeout"] = data["HeartbeatTimeout"]
+    if "Timeout" in data:
+        out["timeout"] = data["Timeout"]
+    return out

capo_lambda/types/callback_succeeded_details.py

@@ -0,0 +1,35 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#CallbackSucceededDetails``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_lambda.types.event_result
+
+
+class CallbackSucceededDetails(TypedDict, closed=True):
+    result: "capo_lambda.types.event_result.EventResult"
+    """<p>The response payload from the successful operation.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: CallbackSucceededDetails) -> dict:
+    out: dict = {}
+    import capo_lambda.types.event_result
+
+    out["Result"] = capo_lambda.types.event_result.serialize_json(value["result"])
+    return out
+
+
+def deserialize_json(data: dict) -> CallbackSucceededDetails:
+    out: CallbackSucceededDetails = {}  # type: ignore[typeddict-item]
+    if "Result" in data:
+        import capo_lambda.types.event_result
+
+        out["result"] = capo_lambda.types.event_result.deserialize_json(data["Result"])
+    else:
+        raise DeserializationError("CallbackSucceededDetails.result required")
+    return out