capo-lambda 0.5.0__py3-none-any.whl

capo_lambda/types/step_details.py

@@ -0,0 +1,68 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#StepDetails``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.attempt_count
+    import capo_lambda.types.error_object
+    import capo_lambda.types.execution_timestamp
+    import capo_lambda.types.operation_payload
+
+
+class StepDetails(TypedDict, closed=True):
+    attempt: "capo_lambda.types.attempt_count.AttemptCount"
+    """<p>The current attempt number for this step.</p>"""
+    next_attempt_timestamp: NotRequired[
+        "capo_lambda.types.execution_timestamp.ExecutionTimestamp"
+    ]
+    r"""<p>The date and time when the next attempt is scheduled, in <a href=\"https://www.w3.org/TR/NOTE-datetime\">ISO-8601 format</a> (YYYY-MM-DDThh:mm:ss.sTZD). Only populated when the step is in a pending state.</p>"""
+    result: NotRequired["capo_lambda.types.operation_payload.OperationPayload"]
+    """<p>The JSON response payload from the step operation.</p>"""
+    error: NotRequired["capo_lambda.types.error_object.ErrorObject"]
+    """<p>Details about the step failure.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: StepDetails) -> dict:
+    out: dict = {}
+    out["Attempt"] = value.get("attempt", 0)
+    if "next_attempt_timestamp" in value:
+        import capo_lambda.types.execution_timestamp
+
+        out["NextAttemptTimestamp"] = (
+            capo_lambda.types.execution_timestamp.serialize_json(
+                value["next_attempt_timestamp"]
+            )
+        )
+    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) -> StepDetails:
+    out: StepDetails = {}  # type: ignore[typeddict-item]
+    if "Attempt" in data:
+        out["attempt"] = data["Attempt"]
+    else:
+        out["attempt"] = 0
+    if "NextAttemptTimestamp" in data:
+        import capo_lambda.types.execution_timestamp
+
+        out["next_attempt_timestamp"] = (
+            capo_lambda.types.execution_timestamp.deserialize_json(
+                data["NextAttemptTimestamp"]
+            )
+        )
+    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/step_failed_details.py

@@ -0,0 +1,51 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#StepFailedDetails``."""
+
+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
+    import capo_lambda.types.retry_details
+
+
+class StepFailedDetails(TypedDict, closed=True):
+    error: "capo_lambda.types.event_error.EventError"
+    """<p>Details about the step failure.</p>"""
+    retry_details: "capo_lambda.types.retry_details.RetryDetails"
+    """<p>Information about retry attempts for this step operation.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: StepFailedDetails) -> dict:
+    out: dict = {}
+    import capo_lambda.types.event_error
+
+    out["Error"] = capo_lambda.types.event_error.serialize_json(value["error"])
+    import capo_lambda.types.retry_details
+
+    out["RetryDetails"] = capo_lambda.types.retry_details.serialize_json(
+        value["retry_details"]
+    )
+    return out
+
+
+def deserialize_json(data: dict) -> StepFailedDetails:
+    out: StepFailedDetails = {}  # 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("StepFailedDetails.error required")
+    if "RetryDetails" in data:
+        import capo_lambda.types.retry_details
+
+        out["retry_details"] = capo_lambda.types.retry_details.deserialize_json(
+            data["RetryDetails"]
+        )
+    else:
+        raise DeserializationError("StepFailedDetails.retry_details required")
+    return out

capo_lambda/types/step_options.py

@@ -0,0 +1,30 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#StepOptions``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.duration_seconds
+
+
+class StepOptions(TypedDict, closed=True):
+    next_attempt_delay_seconds: NotRequired[
+        "capo_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

capo_lambda/types/step_started_details.py

@@ -0,0 +1,18 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#StepStartedDetails``."""
+
+from typing_extensions import TypedDict
+
+
+class StepStartedDetails(TypedDict, closed=True):
+    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

capo_lambda/types/step_succeeded_details.py

@@ -0,0 +1,51 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#StepSucceededDetails``."""
+
+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
+    import capo_lambda.types.retry_details
+
+
+class StepSucceededDetails(TypedDict, closed=True):
+    result: "capo_lambda.types.event_result.EventResult"
+    """<p>The response payload from the successful operation.</p>"""
+    retry_details: "capo_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 capo_lambda.types.event_result
+
+    out["Result"] = capo_lambda.types.event_result.serialize_json(value["result"])
+    import capo_lambda.types.retry_details
+
+    out["RetryDetails"] = capo_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 capo_lambda.types.event_result
+
+        out["result"] = capo_lambda.types.event_result.deserialize_json(data["Result"])
+    else:
+        raise DeserializationError("StepSucceededDetails.result required")
+    if "RetryDetails" in data:
+        import capo_lambda.types.retry_details
+
+        out["retry_details"] = capo_lambda.types.retry_details.deserialize_json(
+            data["RetryDetails"]
+        )
+    else:
+        raise DeserializationError("StepSucceededDetails.retry_details required")
+    return out

capo_lambda/types/stop_durable_execution_request.py

@@ -0,0 +1,35 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#StopDurableExecutionRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.durable_execution_arn
+    import capo_lambda.types.error_object
+
+
+class StopDurableExecutionRequest(TypedDict, closed=True):
+    durable_execution_arn: "capo_lambda.types.durable_execution_arn.DurableExecutionArn"
+    """<p>The Amazon Resource Name (ARN) of the durable execution.</p>"""
+    error: NotRequired["capo_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 capo_lambda.types.error_object
+
+        out["Error"] = capo_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 capo_lambda.types.error_object
+
+        out["error"] = capo_lambda.types.error_object.deserialize_json(data["Error"])
+    return out

capo_lambda/types/stop_durable_execution_response.py

@@ -0,0 +1,41 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#StopDurableExecutionResponse``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_lambda.types.execution_timestamp
+
+
+class StopDurableExecutionResponse(TypedDict, closed=True):
+    stop_timestamp: "capo_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 capo_lambda.types.execution_timestamp
+
+    out["StopTimestamp"] = capo_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 capo_lambda.types.execution_timestamp
+
+        out["stop_timestamp"] = capo_lambda.types.execution_timestamp.deserialize_json(
+            data["StopTimestamp"]
+        )
+    else:
+        raise DeserializationError(
+            "StopDurableExecutionResponse.stop_timestamp required"
+        )
+    return out

capo_lambda/types/string.py

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

capo_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 capo_lambda.types.string
+
+StringList: TypeAlias = list["capo_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)

capo_lambda/types/subnet_id.py

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

capo_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 capo_lambda.types.subnet_id
+
+SubnetIds: TypeAlias = list["capo_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)

capo_lambda/types/system_log_level.py

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

capo_lambda/types/tag_key.py

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

capo_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 capo_lambda.types.tag_key
+
+TagKeyList: TypeAlias = list["capo_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)

capo_lambda/types/tag_resource_request.py

@@ -0,0 +1,38 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#TagResourceRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_lambda.types.taggable_resource
+    import capo_lambda.types.tags
+
+
+class TagResourceRequest(TypedDict, closed=True):
+    resource: "capo_lambda.types.taggable_resource.TaggableResource"
+    """<p>The resource's Amazon Resource Name (ARN).</p>"""
+    tags: "capo_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 capo_lambda.types.tags
+
+    out["Tags"] = capo_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 capo_lambda.types.tags
+
+        out["tags"] = capo_lambda.types.tags.deserialize_json(data["Tags"])
+    else:
+        raise DeserializationError("TagResourceRequest.tags required")
+    return out

capo_lambda/types/tag_value.py

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

capo_lambda/types/taggable_resource.py

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

capo_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 capo_lambda.types.tag_key
+    import capo_lambda.types.tag_value
+
+Tags: TypeAlias = dict[
+    "capo_lambda.types.tag_key.TagKey", "capo_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

capo_lambda/types/tags_error.py

@@ -0,0 +1,39 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#TagsError``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_lambda.types.tags_error_code
+    import capo_lambda.types.tags_error_message
+
+
+class TagsError(TypedDict, closed=True):
+    error_code: "capo_lambda.types.tags_error_code.TagsErrorCode"
+    """<p>The error code.</p>"""
+    message: "capo_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

capo_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

capo_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

capo_lambda/types/target_tracking_scaling_policy.py

@@ -0,0 +1,53 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#TargetTrackingScalingPolicy``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_lambda.types.capacity_provider_predefined_metric_type
+    import capo_lambda.types.metric_target_value
+
+
+class TargetTrackingScalingPolicy(TypedDict, closed=True):
+    predefined_metric_type: "capo_lambda.types.capacity_provider_predefined_metric_type.CapacityProviderPredefinedMetricType"
+    """<p>The predefined metric type to track for scaling decisions.</p>"""
+    target_value: "capo_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 capo_lambda.types.capacity_provider_predefined_metric_type
+
+    out["PredefinedMetricType"] = (
+        capo_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 capo_lambda.types.capacity_provider_predefined_metric_type
+
+        out["predefined_metric_type"] = (
+            capo_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

capo_lambda/types/tenancy_config.py

@@ -0,0 +1,41 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#TenancyConfig``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_lambda.types.tenant_isolation_mode
+
+
+class TenancyConfig(TypedDict, closed=True):
+    tenant_isolation_mode: "capo_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 capo_lambda.types.tenant_isolation_mode
+
+    out["TenantIsolationMode"] = capo_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 capo_lambda.types.tenant_isolation_mode
+
+        out["tenant_isolation_mode"] = (
+            capo_lambda.types.tenant_isolation_mode.deserialize_json(
+                data["TenantIsolationMode"]
+            )
+        )
+    else:
+        raise DeserializationError("TenancyConfig.tenant_isolation_mode required")
+    return out

capo_lambda/types/tenant_id.py

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

capo_lambda/types/tenant_isolation_mode.py

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

capo_lambda/types/throttle_reason.py

@@ -0,0 +1,21 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#ThrottleReason``."""
+
+from typing import Literal, TypeAlias, cast
+
+ThrottleReason: TypeAlias = Literal[
+    "ConcurrentInvocationLimitExceeded",
+    "FunctionInvocationRateLimitExceeded",
+    "ReservedFunctionConcurrentInvocationLimitExceeded",
+    "ReservedFunctionInvocationRateLimitExceeded",
+    "CallerRateLimitExceeded",
+    "ConcurrentSnapshotCreateLimitExceeded",
+]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ThrottleReason) -> str:
+    return value
+
+
+def deserialize_json(data: str) -> ThrottleReason:
+    return cast(ThrottleReason, data)