capo-lambda 0.5.0__py3-none-any.whl

capo_lambda/types/event_source_mapping_system_log_level.py

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

capo_lambda/types/event_source_mappings_list.py

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

capo_lambda/types/event_source_position.py

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

capo_lambda/types/event_source_token.py

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

capo_lambda/types/event_type.py

@@ -0,0 +1,39 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#EventType``."""
+
+from typing import Literal, TypeAlias, cast
+
+EventType: TypeAlias = Literal[
+    "ExecutionStarted",
+    "ExecutionSucceeded",
+    "ExecutionFailed",
+    "ExecutionTimedOut",
+    "ExecutionStopped",
+    "ContextStarted",
+    "ContextSucceeded",
+    "ContextFailed",
+    "WaitStarted",
+    "WaitSucceeded",
+    "WaitCancelled",
+    "StepStarted",
+    "StepSucceeded",
+    "StepFailed",
+    "ChainedInvokeStarted",
+    "ChainedInvokeSucceeded",
+    "ChainedInvokeFailed",
+    "ChainedInvokeTimedOut",
+    "ChainedInvokeStopped",
+    "CallbackStarted",
+    "CallbackSucceeded",
+    "CallbackFailed",
+    "CallbackTimedOut",
+    "InvocationCompleted",
+]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: EventType) -> str:
+    return value
+
+
+def deserialize_json(data: str) -> EventType:
+    return cast(EventType, data)

capo_lambda/types/events.py

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

capo_lambda/types/execution.py

@@ -0,0 +1,95 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#Execution``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_lambda.types.durable_execution_arn
+    import capo_lambda.types.durable_execution_name
+    import capo_lambda.types.execution_status
+    import capo_lambda.types.execution_timestamp
+    import capo_lambda.types.name_spaced_function_arn
+
+
+class Execution(TypedDict, closed=True):
+    durable_execution_arn: "capo_lambda.types.durable_execution_arn.DurableExecutionArn"
+    """<p>The Amazon Resource Name (ARN) of the durable execution, if this execution is a durable execution.</p>"""
+    durable_execution_name: (
+        "capo_lambda.types.durable_execution_name.DurableExecutionName"
+    )
+    """<p>The unique name of the durable execution, if one was provided when the execution was started.</p>"""
+    function_arn: "capo_lambda.types.name_spaced_function_arn.NameSpacedFunctionArn"
+    """<p>The Amazon Resource Name (ARN) of the Lambda function.</p>"""
+    status: "capo_lambda.types.execution_status.ExecutionStatus"
+    """<p>The current status of the durable execution.</p>"""
+    start_timestamp: "capo_lambda.types.execution_timestamp.ExecutionTimestamp"
+    r"""<p>The date and time when the durable execution started, in <a href=\"https://www.w3.org/TR/NOTE-datetime\">ISO-8601 format</a> (YYYY-MM-DDThh:mm:ss.sTZD).</p>"""
+    end_timestamp: NotRequired[
+        "capo_lambda.types.execution_timestamp.ExecutionTimestamp"
+    ]
+    r"""<p>The date and time when the durable execution ended, in <a href=\"https://www.w3.org/TR/NOTE-datetime\">ISO-8601 format</a> (YYYY-MM-DDThh:mm:ss.sTZD).</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: Execution) -> dict:
+    out: dict = {}
+    out["DurableExecutionArn"] = value["durable_execution_arn"]
+    out["DurableExecutionName"] = value["durable_execution_name"]
+    out["FunctionArn"] = value["function_arn"]
+    import capo_lambda.types.execution_status
+
+    out["Status"] = capo_lambda.types.execution_status.serialize_json(value["status"])
+    import capo_lambda.types.execution_timestamp
+
+    out["StartTimestamp"] = capo_lambda.types.execution_timestamp.serialize_json(
+        value["start_timestamp"]
+    )
+    if "end_timestamp" in value:
+        import capo_lambda.types.execution_timestamp
+
+        out["EndTimestamp"] = capo_lambda.types.execution_timestamp.serialize_json(
+            value["end_timestamp"]
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> Execution:
+    out: Execution = {}  # type: ignore[typeddict-item]
+    if "DurableExecutionArn" in data:
+        out["durable_execution_arn"] = data["DurableExecutionArn"]
+    else:
+        raise DeserializationError("Execution.durable_execution_arn required")
+    if "DurableExecutionName" in data:
+        out["durable_execution_name"] = data["DurableExecutionName"]
+    else:
+        raise DeserializationError("Execution.durable_execution_name required")
+    if "FunctionArn" in data:
+        out["function_arn"] = data["FunctionArn"]
+    else:
+        raise DeserializationError("Execution.function_arn required")
+    if "Status" in data:
+        import capo_lambda.types.execution_status
+
+        out["status"] = capo_lambda.types.execution_status.deserialize_json(
+            data["Status"]
+        )
+    else:
+        raise DeserializationError("Execution.status required")
+    if "StartTimestamp" in data:
+        import capo_lambda.types.execution_timestamp
+
+        out["start_timestamp"] = capo_lambda.types.execution_timestamp.deserialize_json(
+            data["StartTimestamp"]
+        )
+    else:
+        raise DeserializationError("Execution.start_timestamp required")
+    if "EndTimestamp" in data:
+        import capo_lambda.types.execution_timestamp
+
+        out["end_timestamp"] = capo_lambda.types.execution_timestamp.deserialize_json(
+            data["EndTimestamp"]
+        )
+    return out

capo_lambda/types/execution_details.py

@@ -0,0 +1,28 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#ExecutionDetails``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.input_payload
+
+
+class ExecutionDetails(TypedDict, closed=True):
+    input_payload: NotRequired["capo_lambda.types.input_payload.InputPayload"]
+    """<p>The original input payload provided for the durable execution.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ExecutionDetails) -> dict:
+    out: dict = {}
+    if "input_payload" in value:
+        out["InputPayload"] = value["input_payload"]
+    return out
+
+
+def deserialize_json(data: dict) -> ExecutionDetails:
+    out: ExecutionDetails = {}  # type: ignore[typeddict-item]
+    if "InputPayload" in data:
+        out["input_payload"] = data["InputPayload"]
+    return out

capo_lambda/types/execution_environment_memory_gi_b_per_v_cpu.py

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

capo_lambda/types/execution_failed_details.py

@@ -0,0 +1,35 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#ExecutionFailedDetails``."""
+
+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 ExecutionFailedDetails(TypedDict, closed=True):
+    error: "capo_lambda.types.event_error.EventError"
+    """<p>Details about the execution failure.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ExecutionFailedDetails) -> 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) -> ExecutionFailedDetails:
+    out: ExecutionFailedDetails = {}  # 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("ExecutionFailedDetails.error required")
+    return out

capo_lambda/types/execution_started_details.py

@@ -0,0 +1,43 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#ExecutionStartedDetails``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_lambda.types.duration_seconds
+    import capo_lambda.types.event_input
+
+
+class ExecutionStartedDetails(TypedDict, closed=True):
+    input: "capo_lambda.types.event_input.EventInput"
+    """<p>The input payload provided for the durable execution.</p>"""
+    execution_timeout: "capo_lambda.types.duration_seconds.DurationSeconds"
+    """<p>The maximum amount of time that the durable execution is allowed to run, in seconds.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ExecutionStartedDetails) -> dict:
+    out: dict = {}
+    import capo_lambda.types.event_input
+
+    out["Input"] = capo_lambda.types.event_input.serialize_json(value["input"])
+    out["ExecutionTimeout"] = value["execution_timeout"]
+    return out
+
+
+def deserialize_json(data: dict) -> ExecutionStartedDetails:
+    out: ExecutionStartedDetails = {}  # type: ignore[typeddict-item]
+    if "Input" in data:
+        import capo_lambda.types.event_input
+
+        out["input"] = capo_lambda.types.event_input.deserialize_json(data["Input"])
+    else:
+        raise DeserializationError("ExecutionStartedDetails.input required")
+    if "ExecutionTimeout" in data:
+        out["execution_timeout"] = data["ExecutionTimeout"]
+    else:
+        raise DeserializationError("ExecutionStartedDetails.execution_timeout required")
+    return out

capo_lambda/types/execution_status.py

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

capo_lambda/types/execution_status_list.py

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

capo_lambda/types/execution_stopped_details.py

@@ -0,0 +1,35 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#ExecutionStoppedDetails``."""
+
+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 ExecutionStoppedDetails(TypedDict, closed=True):
+    error: "capo_lambda.types.event_error.EventError"
+    """<p>Details about why the execution stopped.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ExecutionStoppedDetails) -> 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) -> ExecutionStoppedDetails:
+    out: ExecutionStoppedDetails = {}  # 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("ExecutionStoppedDetails.error required")
+    return out

capo_lambda/types/execution_succeeded_details.py

@@ -0,0 +1,35 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#ExecutionSucceededDetails``."""
+
+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 ExecutionSucceededDetails(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: ExecutionSucceededDetails) -> 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) -> ExecutionSucceededDetails:
+    out: ExecutionSucceededDetails = {}  # 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("ExecutionSucceededDetails.result required")
+    return out

capo_lambda/types/execution_timed_out_details.py

@@ -0,0 +1,32 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#ExecutionTimedOutDetails``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.event_error
+
+
+class ExecutionTimedOutDetails(TypedDict, closed=True):
+    error: NotRequired["capo_lambda.types.event_error.EventError"]
+    """<p>Details about the execution timeout.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ExecutionTimedOutDetails) -> dict:
+    out: dict = {}
+    if "error" in value:
+        import capo_lambda.types.event_error
+
+        out["Error"] = capo_lambda.types.event_error.serialize_json(value["error"])
+    return out
+
+
+def deserialize_json(data: dict) -> ExecutionTimedOutDetails:
+    out: ExecutionTimedOutDetails = {}  # 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"])
+    return out

capo_lambda/types/execution_timeout.py

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

capo_lambda/types/execution_timestamp.py

@@ -0,0 +1,15 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#ExecutionTimestamp``."""
+
+import datetime
+from typing import TypeAlias
+
+ExecutionTimestamp: TypeAlias = datetime.datetime
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ExecutionTimestamp) -> float:
+    return value.timestamp()
+
+
+def deserialize_json(data: float) -> ExecutionTimestamp:
+    return datetime.datetime.fromtimestamp(float(data), tz=datetime.timezone.utc)

capo_lambda/types/file_system_arn.py

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

capo_lambda/types/file_system_config.py

@@ -0,0 +1,39 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#FileSystemConfig``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_lambda.types.file_system_arn
+    import capo_lambda.types.local_mount_path
+
+
+class FileSystemConfig(TypedDict, closed=True):
+    arn: "capo_lambda.types.file_system_arn.FileSystemArn"
+    """<p>The Amazon Resource Name (ARN) of the Amazon EFS or Amazon S3 Files access point that provides access to the file system.</p>"""
+    local_mount_path: "capo_lambda.types.local_mount_path.LocalMountPath"
+    """<p>The path where the function can access the file system, starting with <code>/mnt/</code>.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: FileSystemConfig) -> dict:
+    out: dict = {}
+    out["Arn"] = value["arn"]
+    out["LocalMountPath"] = value["local_mount_path"]
+    return out
+
+
+def deserialize_json(data: dict) -> FileSystemConfig:
+    out: FileSystemConfig = {}  # type: ignore[typeddict-item]
+    if "Arn" in data:
+        out["arn"] = data["Arn"]
+    else:
+        raise DeserializationError("FileSystemConfig.arn required")
+    if "LocalMountPath" in data:
+        out["local_mount_path"] = data["LocalMountPath"]
+    else:
+        raise DeserializationError("FileSystemConfig.local_mount_path required")
+    return out

capo_lambda/types/file_system_config_list.py

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

capo_lambda/types/filter.py

@@ -0,0 +1,28 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#Filter``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.pattern
+
+
+class Filter(TypedDict, closed=True):
+    pattern: NotRequired["capo_lambda.types.pattern.Pattern"]
+    r"""<p> A filter pattern. For more information on the syntax of a filter pattern, see <a href=\"https://docs.aws.amazon.com/lambda/latest/dg/invocation-eventfiltering.html#filtering-syntax\"> Filter rule syntax</a>. </p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: Filter) -> dict:
+    out: dict = {}
+    if "pattern" in value:
+        out["Pattern"] = value["pattern"]
+    return out
+
+
+def deserialize_json(data: dict) -> Filter:
+    out: Filter = {}  # type: ignore[typeddict-item]
+    if "Pattern" in data:
+        out["pattern"] = data["Pattern"]
+    return out