capo-lambda 0.5.0__py3-none-any.whl

capo_lambda/types/vpc_config_response.py

@@ -0,0 +1,71 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#VpcConfigResponse``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.nullable_boolean
+    import capo_lambda.types.security_group_ids
+    import capo_lambda.types.subnet_ids
+    import capo_lambda.types.vpc_id
+
+
+class VpcConfigResponse(TypedDict, closed=True):
+    subnet_ids: NotRequired["capo_lambda.types.subnet_ids.SubnetIds"]
+    """<p>A list of VPC subnet IDs.</p>"""
+    security_group_ids: NotRequired[
+        "capo_lambda.types.security_group_ids.SecurityGroupIds"
+    ]
+    """<p>A list of VPC security group IDs.</p>"""
+    vpc_id: NotRequired["capo_lambda.types.vpc_id.VpcId"]
+    """<p>The ID of the VPC.</p>"""
+    ipv6_allowed_for_dual_stack: NotRequired[
+        "capo_lambda.types.nullable_boolean.NullableBoolean"
+    ]
+    """<p>Allows outbound IPv6 traffic on VPC functions that are connected to dual-stack subnets.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: VpcConfigResponse) -> dict:
+    out: dict = {}
+    if "subnet_ids" in value:
+        import capo_lambda.types.subnet_ids
+
+        out["SubnetIds"] = capo_lambda.types.subnet_ids.serialize_json(
+            value["subnet_ids"]
+        )
+    if "security_group_ids" in value:
+        import capo_lambda.types.security_group_ids
+
+        out["SecurityGroupIds"] = capo_lambda.types.security_group_ids.serialize_json(
+            value["security_group_ids"]
+        )
+    if "vpc_id" in value:
+        out["VpcId"] = value["vpc_id"]
+    if "ipv6_allowed_for_dual_stack" in value:
+        out["Ipv6AllowedForDualStack"] = value["ipv6_allowed_for_dual_stack"]
+    return out
+
+
+def deserialize_json(data: dict) -> VpcConfigResponse:
+    out: VpcConfigResponse = {}  # type: ignore[typeddict-item]
+    if "SubnetIds" in data:
+        import capo_lambda.types.subnet_ids
+
+        out["subnet_ids"] = capo_lambda.types.subnet_ids.deserialize_json(
+            data["SubnetIds"]
+        )
+    if "SecurityGroupIds" in data:
+        import capo_lambda.types.security_group_ids
+
+        out["security_group_ids"] = (
+            capo_lambda.types.security_group_ids.deserialize_json(
+                data["SecurityGroupIds"]
+            )
+        )
+    if "VpcId" in data:
+        out["vpc_id"] = data["VpcId"]
+    if "Ipv6AllowedForDualStack" in data:
+        out["ipv6_allowed_for_dual_stack"] = data["Ipv6AllowedForDualStack"]
+    return out

capo_lambda/types/vpc_id.py

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

capo_lambda/types/wait_cancelled_details.py

@@ -0,0 +1,32 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#WaitCancelledDetails``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.event_error
+
+
+class WaitCancelledDetails(TypedDict, closed=True):
+    error: NotRequired["capo_lambda.types.event_error.EventError"]
+    """<p>Details about why the wait operation was cancelled.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: WaitCancelledDetails) -> 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) -> WaitCancelledDetails:
+    out: WaitCancelledDetails = {}  # 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/wait_details.py

@@ -0,0 +1,42 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#WaitDetails``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.execution_timestamp
+
+
+class WaitDetails(TypedDict, closed=True):
+    scheduled_end_timestamp: NotRequired[
+        "capo_lambda.types.execution_timestamp.ExecutionTimestamp"
+    ]
+    r"""<p>The date and time when the wait operation is scheduled to complete, 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: WaitDetails) -> dict:
+    out: dict = {}
+    if "scheduled_end_timestamp" in value:
+        import capo_lambda.types.execution_timestamp
+
+        out["ScheduledEndTimestamp"] = (
+            capo_lambda.types.execution_timestamp.serialize_json(
+                value["scheduled_end_timestamp"]
+            )
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> WaitDetails:
+    out: WaitDetails = {}  # type: ignore[typeddict-item]
+    if "ScheduledEndTimestamp" in data:
+        import capo_lambda.types.execution_timestamp
+
+        out["scheduled_end_timestamp"] = (
+            capo_lambda.types.execution_timestamp.deserialize_json(
+                data["ScheduledEndTimestamp"]
+            )
+        )
+    return out

capo_lambda/types/wait_options.py

@@ -0,0 +1,28 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#WaitOptions``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.duration_seconds
+
+
+class WaitOptions(TypedDict, closed=True):
+    wait_seconds: NotRequired["capo_lambda.types.duration_seconds.DurationSeconds"]
+    """<p>The duration to wait, in seconds.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: WaitOptions) -> dict:
+    out: dict = {}
+    if "wait_seconds" in value:
+        out["WaitSeconds"] = value["wait_seconds"]
+    return out
+
+
+def deserialize_json(data: dict) -> WaitOptions:
+    out: WaitOptions = {}  # type: ignore[typeddict-item]
+    if "WaitSeconds" in data:
+        out["wait_seconds"] = data["WaitSeconds"]
+    return out

capo_lambda/types/wait_started_details.py

@@ -0,0 +1,51 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#WaitStartedDetails``."""
+
+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.execution_timestamp
+
+
+class WaitStartedDetails(TypedDict, closed=True):
+    duration: "capo_lambda.types.duration_seconds.DurationSeconds"
+    """<p>The duration to wait, in seconds.</p>"""
+    scheduled_end_timestamp: "capo_lambda.types.execution_timestamp.ExecutionTimestamp"
+    r"""<p>The date and time when the wait operation is scheduled to complete, 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: WaitStartedDetails) -> dict:
+    out: dict = {}
+    out["Duration"] = value["duration"]
+    import capo_lambda.types.execution_timestamp
+
+    out["ScheduledEndTimestamp"] = capo_lambda.types.execution_timestamp.serialize_json(
+        value["scheduled_end_timestamp"]
+    )
+    return out
+
+
+def deserialize_json(data: dict) -> WaitStartedDetails:
+    out: WaitStartedDetails = {}  # type: ignore[typeddict-item]
+    if "Duration" in data:
+        out["duration"] = data["Duration"]
+    else:
+        raise DeserializationError("WaitStartedDetails.duration required")
+    if "ScheduledEndTimestamp" in data:
+        import capo_lambda.types.execution_timestamp
+
+        out["scheduled_end_timestamp"] = (
+            capo_lambda.types.execution_timestamp.deserialize_json(
+                data["ScheduledEndTimestamp"]
+            )
+        )
+    else:
+        raise DeserializationError(
+            "WaitStartedDetails.scheduled_end_timestamp required"
+        )
+    return out

capo_lambda/types/wait_succeeded_details.py

@@ -0,0 +1,28 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#WaitSucceededDetails``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.duration_seconds
+
+
+class WaitSucceededDetails(TypedDict, closed=True):
+    duration: NotRequired["capo_lambda.types.duration_seconds.DurationSeconds"]
+    """<p>The wait duration, in seconds.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: WaitSucceededDetails) -> dict:
+    out: dict = {}
+    if "duration" in value:
+        out["Duration"] = value["duration"]
+    return out
+
+
+def deserialize_json(data: dict) -> WaitSucceededDetails:
+    out: WaitSucceededDetails = {}  # type: ignore[typeddict-item]
+    if "Duration" in data:
+        out["duration"] = data["Duration"]
+    return out

capo_lambda/types/weight.py

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

capo_lambda/types/working_directory.py

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

capo_lambda/types/x_amzn_trace_id.py

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

capo_lambda-0.5.0.dist-info/METADATA

@@ -0,0 +1,97 @@
+Metadata-Version: 2.4
+Name: capo-lambda
+Version: 0.5.0
+Summary: Python SDK for AWS Lambda.
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Code Generators
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: zapros>=0.13.0
+Dynamic: license-file
+
+# Getting Started
+
+## Installation
+
+```
+pip install capo-lambda
+```
+
+## Usage
+
+```python
+from capo_lambda import AsyncLambdaClient
+
+
+async def main():
+    async with AsyncLambdaClient() as s3:
+        # Example: call the checkpoint_durable_execution operation
+        response = await s3.checkpoint_durable_execution()
+        print(response["checkpoint_token"])
+```
+
+## Pagination
+
+Some operations in this SDK support pagination. If the operation supports pagination it will have an `iter_` prefixed method that returns an async iterator.
+
+```python
+from capo_lambda import AsyncLambdaClient
+
+
+async def main():
+    async with AsyncLambdaClient() as s3:
+        # Example: paginate over get_durable_execution_history
+        async for item in s3.iter_get_durable_execution_history():
+            print(item)
+```
+
+## Error Handling
+
+The SDK raises exceptions for errors returned by the API. Catch them to handle failures gracefully.
+
+```python
+from capo_lambda import AsyncLambdaClient
+from capo_lambda.error import InvalidParameterValueException
+
+
+async def main():
+    async with AsyncLambdaClient() as s3:
+        try:
+            await s3.checkpoint_durable_execution()
+        except InvalidParameterValueException as e:
+            print(f"Error: {e}")
+            print(e.data)  # additional error data
+```
+
+## Retrying
+
+The SDK retries failed operations automatically. Retry behaviour follows the Smithy specification: errors are retried based on their `is_retryable` and `is_throttling_error` attributes. Throttling errors use a longer base delay. Network-level failures (connection errors and timeouts) are also retried. Non-retryable errors, such as client errors without the `@retryable` trait, are raised immediately without further attempts.
+
+The number of attempts defaults to 3 and can be changed at the client level via `retry_max_attempts`, or per call via `config_overrides`.
+
+```python
+from capo_lambda import AsyncLambdaClient
+
+
+async def main():
+    async with AsyncLambdaClient() as s3:
+        # Default: 3 attempts for every operation
+        response = await s3.checkpoint_durable_execution()
+
+        # Override per operation
+        response = await s3.checkpoint_durable_execution(config_overrides={"retry_max_attempts": 5})
+
+        # Disable retries for this call
+        response = await s3.checkpoint_durable_execution(config_overrides={"retry_max_attempts": 1})
+```