aws-sdk-lambda 0.4.0__py3-none-any.whl

aws_sdk_lambda/types/step_options.py

@@ -0,0 +1,30 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#StepOptions``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.duration_seconds
+
+
+class StepOptions(TypedDict):
+    next_attempt_delay_seconds: NotRequired[
+        "aws_sdk_lambda.types.duration_seconds.DurationSeconds"
+    ]
+    """<p>The delay in seconds before the next retry attempt.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: StepOptions) -> dict:
+    out: dict = {}
+    if "next_attempt_delay_seconds" in value:
+        out["NextAttemptDelaySeconds"] = value["next_attempt_delay_seconds"]
+    return out
+
+
+def deserialize_json(data: dict) -> StepOptions:
+    out: StepOptions = {}  # type: ignore[typeddict-item]
+    if "NextAttemptDelaySeconds" in data:
+        out["next_attempt_delay_seconds"] = data["NextAttemptDelaySeconds"]
+    return out

aws_sdk_lambda/types/step_started_details.py

@@ -0,0 +1,18 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#StepStartedDetails``."""
+
+from typing import TypedDict
+
+
+class StepStartedDetails(TypedDict):
+    pass
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: StepStartedDetails) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> StepStartedDetails:
+    out: StepStartedDetails = {}  # type: ignore[typeddict-item]
+    return out

aws_sdk_lambda/types/step_succeeded_details.py

@@ -0,0 +1,51 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#StepSucceededDetails``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from aws_sdk_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.event_result
+    import aws_sdk_lambda.types.retry_details
+
+
+class StepSucceededDetails(TypedDict):
+    result: "aws_sdk_lambda.types.event_result.EventResult"
+    """<p>The response payload from the successful operation.</p>"""
+    retry_details: "aws_sdk_lambda.types.retry_details.RetryDetails"
+    """<p>Information about retry attempts for this step operation.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: StepSucceededDetails) -> dict:
+    out: dict = {}
+    import aws_sdk_lambda.types.event_result
+
+    out["Result"] = aws_sdk_lambda.types.event_result.serialize_json(value["result"])
+    import aws_sdk_lambda.types.retry_details
+
+    out["RetryDetails"] = aws_sdk_lambda.types.retry_details.serialize_json(
+        value["retry_details"]
+    )
+    return out
+
+
+def deserialize_json(data: dict) -> StepSucceededDetails:
+    out: StepSucceededDetails = {}  # type: ignore[typeddict-item]
+    if "Result" in data:
+        import aws_sdk_lambda.types.event_result
+
+        out["result"] = aws_sdk_lambda.types.event_result.deserialize_json(
+            data["Result"]
+        )
+    else:
+        raise DeserializationError("StepSucceededDetails.result required")
+    if "RetryDetails" in data:
+        import aws_sdk_lambda.types.retry_details
+
+        out["retry_details"] = aws_sdk_lambda.types.retry_details.deserialize_json(
+            data["RetryDetails"]
+        )
+    else:
+        raise DeserializationError("StepSucceededDetails.retry_details required")
+    return out

aws_sdk_lambda/types/stop_durable_execution_request.py

@@ -0,0 +1,37 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#StopDurableExecutionRequest``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.durable_execution_arn
+    import aws_sdk_lambda.types.error_object
+
+
+class StopDurableExecutionRequest(TypedDict):
+    durable_execution_arn: (
+        "aws_sdk_lambda.types.durable_execution_arn.DurableExecutionArn"
+    )
+    """<p>The Amazon Resource Name (ARN) of the durable execution.</p>"""
+    error: NotRequired["aws_sdk_lambda.types.error_object.ErrorObject"]
+    """<p>Optional error details explaining why the execution is being stopped.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: StopDurableExecutionRequest) -> dict:
+    out: dict = {}
+    if "error" in value:
+        import aws_sdk_lambda.types.error_object
+
+        out["Error"] = aws_sdk_lambda.types.error_object.serialize_json(value["error"])
+    return out
+
+
+def deserialize_json(data: dict) -> StopDurableExecutionRequest:
+    out: StopDurableExecutionRequest = {}  # type: ignore[typeddict-item]
+    if "Error" in data:
+        import aws_sdk_lambda.types.error_object
+
+        out["error"] = aws_sdk_lambda.types.error_object.deserialize_json(data["Error"])
+    return out

aws_sdk_lambda/types/stop_durable_execution_response.py

@@ -0,0 +1,41 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#StopDurableExecutionResponse``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from aws_sdk_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.execution_timestamp
+
+
+class StopDurableExecutionResponse(TypedDict):
+    stop_timestamp: "aws_sdk_lambda.types.execution_timestamp.ExecutionTimestamp"
+    """<p>The timestamp when the execution was stopped (ISO 8601 format).</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: StopDurableExecutionResponse) -> dict:
+    out: dict = {}
+    import aws_sdk_lambda.types.execution_timestamp
+
+    out["StopTimestamp"] = aws_sdk_lambda.types.execution_timestamp.serialize_json(
+        value["stop_timestamp"]
+    )
+    return out
+
+
+def deserialize_json(data: dict) -> StopDurableExecutionResponse:
+    out: StopDurableExecutionResponse = {}  # type: ignore[typeddict-item]
+    if "StopTimestamp" in data:
+        import aws_sdk_lambda.types.execution_timestamp
+
+        out["stop_timestamp"] = (
+            aws_sdk_lambda.types.execution_timestamp.deserialize_json(
+                data["StopTimestamp"]
+            )
+        )
+    else:
+        raise DeserializationError(
+            "StopDurableExecutionResponse.stop_timestamp required"
+        )
+    return out

aws_sdk_lambda/types/string.py

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

aws_sdk_lambda/types/string_list.py

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

aws_sdk_lambda/types/subnet_id.py

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

aws_sdk_lambda/types/subnet_ids.py

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

aws_sdk_lambda/types/system_log_level.py

@@ -0,0 +1,31 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#SystemLogLevel``."""
+
+from typing import Literal, TypeAlias, cast
+
+from aws_sdk_lambda.errors import DeserializationError
+
+SystemLogLevel: TypeAlias = Literal[
+    "DEBUG",
+    "INFO",
+    "WARN",
+]
+
+
+# --- restJson1 ser/de ---
+_VALUES: frozenset[str] = frozenset(
+    (
+        "DEBUG",
+        "INFO",
+        "WARN",
+    )
+)
+
+
+def serialize_json(value: SystemLogLevel) -> str:
+    return value
+
+
+def deserialize_json(data: str) -> SystemLogLevel:
+    if data not in _VALUES:
+        raise DeserializationError(f"unknown SystemLogLevel value: {data!r}")
+    return cast(SystemLogLevel, data)

aws_sdk_lambda/types/tag_key.py

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

aws_sdk_lambda/types/tag_key_list.py

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

aws_sdk_lambda/types/tag_resource_request.py

@@ -0,0 +1,36 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#TagResourceRequest``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from aws_sdk_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.taggable_resource
+    import aws_sdk_lambda.types.tags
+
+
+class TagResourceRequest(TypedDict):
+    resource: "aws_sdk_lambda.types.taggable_resource.TaggableResource"
+    """<p>The resource's Amazon Resource Name (ARN).</p>"""
+    tags: "aws_sdk_lambda.types.tags.Tags"
+    """<p>A list of tags to apply to the resource.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: TagResourceRequest) -> dict:
+    out: dict = {}
+    import aws_sdk_lambda.types.tags
+
+    out["Tags"] = aws_sdk_lambda.types.tags.serialize_json(value["tags"])
+    return out
+
+
+def deserialize_json(data: dict) -> TagResourceRequest:
+    out: TagResourceRequest = {}  # type: ignore[typeddict-item]
+    if "Tags" in data:
+        import aws_sdk_lambda.types.tags
+
+        out["tags"] = aws_sdk_lambda.types.tags.deserialize_json(data["Tags"])
+    else:
+        raise DeserializationError("TagResourceRequest.tags required")
+    return out

aws_sdk_lambda/types/tag_value.py

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

aws_sdk_lambda/types/taggable_resource.py

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

aws_sdk_lambda/types/tags.py

@@ -0,0 +1,26 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#Tags``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.tag_key
+    import aws_sdk_lambda.types.tag_value
+
+Tags: TypeAlias = dict[
+    "aws_sdk_lambda.types.tag_key.TagKey", "aws_sdk_lambda.types.tag_value.TagValue"
+]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(input_to_serialize: Tags) -> dict:
+    out: dict = {}
+    for key, value in input_to_serialize.items():
+        out[key] = value
+    return out
+
+
+def deserialize_json(data: dict) -> Tags:
+    out: Tags = {}
+    for key, value in data.items():
+        out[key] = value
+    return out

aws_sdk_lambda/types/tags_error.py

@@ -0,0 +1,37 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#TagsError``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from aws_sdk_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.tags_error_code
+    import aws_sdk_lambda.types.tags_error_message
+
+
+class TagsError(TypedDict):
+    error_code: "aws_sdk_lambda.types.tags_error_code.TagsErrorCode"
+    """<p>The error code.</p>"""
+    message: "aws_sdk_lambda.types.tags_error_message.TagsErrorMessage"
+    """<p>The error message.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: TagsError) -> dict:
+    out: dict = {}
+    out["ErrorCode"] = value["error_code"]
+    out["Message"] = value["message"]
+    return out
+
+
+def deserialize_json(data: dict) -> TagsError:
+    out: TagsError = {}  # type: ignore[typeddict-item]
+    if "ErrorCode" in data:
+        out["error_code"] = data["ErrorCode"]
+    else:
+        raise DeserializationError("TagsError.error_code required")
+    if "Message" in data:
+        out["message"] = data["Message"]
+    else:
+        raise DeserializationError("TagsError.message required")
+    return out

aws_sdk_lambda/types/tags_error_code.py

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

aws_sdk_lambda/types/tags_error_message.py

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

aws_sdk_lambda/types/target_tracking_scaling_policy.py

@@ -0,0 +1,51 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#TargetTrackingScalingPolicy``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from aws_sdk_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.capacity_provider_predefined_metric_type
+    import aws_sdk_lambda.types.metric_target_value
+
+
+class TargetTrackingScalingPolicy(TypedDict):
+    predefined_metric_type: "aws_sdk_lambda.types.capacity_provider_predefined_metric_type.CapacityProviderPredefinedMetricType"
+    """<p>The predefined metric type to track for scaling decisions.</p>"""
+    target_value: "aws_sdk_lambda.types.metric_target_value.MetricTargetValue"
+    """<p>The target value for the metric that the scaling policy attempts to maintain through scaling actions.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: TargetTrackingScalingPolicy) -> dict:
+    out: dict = {}
+    import aws_sdk_lambda.types.capacity_provider_predefined_metric_type
+
+    out["PredefinedMetricType"] = (
+        aws_sdk_lambda.types.capacity_provider_predefined_metric_type.serialize_json(
+            value["predefined_metric_type"]
+        )
+    )
+    out["TargetValue"] = value["target_value"]
+    return out
+
+
+def deserialize_json(data: dict) -> TargetTrackingScalingPolicy:
+    out: TargetTrackingScalingPolicy = {}  # type: ignore[typeddict-item]
+    if "PredefinedMetricType" in data:
+        import aws_sdk_lambda.types.capacity_provider_predefined_metric_type
+
+        out["predefined_metric_type"] = (
+            aws_sdk_lambda.types.capacity_provider_predefined_metric_type.deserialize_json(
+                data["PredefinedMetricType"]
+            )
+        )
+    else:
+        raise DeserializationError(
+            "TargetTrackingScalingPolicy.predefined_metric_type required"
+        )
+    if "TargetValue" in data:
+        out["target_value"] = data["TargetValue"]
+    else:
+        raise DeserializationError("TargetTrackingScalingPolicy.target_value required")
+    return out

aws_sdk_lambda/types/tenancy_config.py

@@ -0,0 +1,43 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#TenancyConfig``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from aws_sdk_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.tenant_isolation_mode
+
+
+class TenancyConfig(TypedDict):
+    tenant_isolation_mode: (
+        "aws_sdk_lambda.types.tenant_isolation_mode.TenantIsolationMode"
+    )
+    """<p>Tenant isolation mode allows for invocation to be sent to a corresponding execution environment dedicated to a specific tenant ID.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: TenancyConfig) -> dict:
+    out: dict = {}
+    import aws_sdk_lambda.types.tenant_isolation_mode
+
+    out["TenantIsolationMode"] = (
+        aws_sdk_lambda.types.tenant_isolation_mode.serialize_json(
+            value["tenant_isolation_mode"]
+        )
+    )
+    return out
+
+
+def deserialize_json(data: dict) -> TenancyConfig:
+    out: TenancyConfig = {}  # type: ignore[typeddict-item]
+    if "TenantIsolationMode" in data:
+        import aws_sdk_lambda.types.tenant_isolation_mode
+
+        out["tenant_isolation_mode"] = (
+            aws_sdk_lambda.types.tenant_isolation_mode.deserialize_json(
+                data["TenantIsolationMode"]
+            )
+        )
+    else:
+        raise DeserializationError("TenancyConfig.tenant_isolation_mode required")
+    return out

aws_sdk_lambda/types/tenant_id.py

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

aws_sdk_lambda/types/tenant_isolation_mode.py

@@ -0,0 +1,21 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#TenantIsolationMode``."""
+
+from typing import Literal, TypeAlias, cast
+
+from aws_sdk_lambda.errors import DeserializationError
+
+TenantIsolationMode: TypeAlias = Literal["PER_TENANT",]
+
+
+# --- restJson1 ser/de ---
+_VALUES: frozenset[str] = frozenset(("PER_TENANT",))
+
+
+def serialize_json(value: TenantIsolationMode) -> str:
+    return value
+
+
+def deserialize_json(data: str) -> TenantIsolationMode:
+    if data not in _VALUES:
+        raise DeserializationError(f"unknown TenantIsolationMode value: {data!r}")
+    return cast(TenantIsolationMode, data)

aws_sdk_lambda/types/throttle_reason.py

@@ -0,0 +1,37 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#ThrottleReason``."""
+
+from typing import Literal, TypeAlias, cast
+
+from aws_sdk_lambda.errors import DeserializationError
+
+ThrottleReason: TypeAlias = Literal[
+    "ConcurrentInvocationLimitExceeded",
+    "FunctionInvocationRateLimitExceeded",
+    "ReservedFunctionConcurrentInvocationLimitExceeded",
+    "ReservedFunctionInvocationRateLimitExceeded",
+    "CallerRateLimitExceeded",
+    "ConcurrentSnapshotCreateLimitExceeded",
+]
+
+
+# --- restJson1 ser/de ---
+_VALUES: frozenset[str] = frozenset(
+    (
+        "ConcurrentInvocationLimitExceeded",
+        "FunctionInvocationRateLimitExceeded",
+        "ReservedFunctionConcurrentInvocationLimitExceeded",
+        "ReservedFunctionInvocationRateLimitExceeded",
+        "CallerRateLimitExceeded",
+        "ConcurrentSnapshotCreateLimitExceeded",
+    )
+)
+
+
+def serialize_json(value: ThrottleReason) -> str:
+    return value
+
+
+def deserialize_json(data: str) -> ThrottleReason:
+    if data not in _VALUES:
+        raise DeserializationError(f"unknown ThrottleReason value: {data!r}")
+    return cast(ThrottleReason, data)

aws_sdk_lambda/types/timeout.py

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

aws_sdk_lambda/types/timestamp.py

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

aws_sdk_lambda/types/topic.py

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

aws_sdk_lambda/types/topics.py

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

aws_sdk_lambda/types/trace_header.py

@@ -0,0 +1,28 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#TraceHeader``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.x_amzn_trace_id
+
+
+class TraceHeader(TypedDict):
+    x_amzn_trace_id: NotRequired["aws_sdk_lambda.types.x_amzn_trace_id.XAmznTraceId"]
+    """<p>The X-Ray trace header associated with the durable execution.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: TraceHeader) -> dict:
+    out: dict = {}
+    if "x_amzn_trace_id" in value:
+        out["XAmznTraceId"] = value["x_amzn_trace_id"]
+    return out
+
+
+def deserialize_json(data: dict) -> TraceHeader:
+    out: TraceHeader = {}  # type: ignore[typeddict-item]
+    if "XAmznTraceId" in data:
+        out["x_amzn_trace_id"] = data["XAmznTraceId"]
+    return out