async-lambda-unstable 0.5.7__tar.gz → 0.6.0__tar.gz

async_lambda_unstable-0.6.0/.gitignore

@@ -0,0 +1,164 @@
+*samconfig.toml
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+*.DS_Store
+uv.lock

{async-lambda-unstable-0.5.7 → async_lambda_unstable-0.6.0}/PKG-INFO

@@ -1,10 +1,14 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: async-lambda-unstable
-Version: 0.5.7
+Version: 0.6.0
 Summary: A framework for creating AWS Lambda Async Workflows. - Unstable Branch
 Author-email: "Nuclei, Inc" <engineering@nuclei.ai>
-Description-Content-Type: text/markdown
+Requires-Dist: click>=8.0.0
+Requires-Dist: typing-extensions>=4.0.0
 Provides-Extra: local
+Requires-Dist: boto3; extra == 'local'
+Requires-Dist: flask<3.0.0,>=2.3.0; extra == 'local'
+Description-Content-Type: text/markdown
 
 # async-lambda
 

{async-lambda-unstable-0.5.7 → async_lambda_unstable-0.6.0}/async_lambda/__init__.py

@@ -21,4 +21,4 @@ from .models.events.managed_sqs_event import ManagedSQSEvent as ManagedSQSEvent
 from .models.events.scheduled_event import ScheduledEvent as ScheduledEvent
 from .models.events.unmanaged_sqs_event import UnmanagedSQSEvent as UnmanagedSQSEvent
 
-__version__ = "0.5.7"
+__version__ = "0.6.0"

{async-lambda-unstable-0.5.7 → async_lambda_unstable-0.6.0}/async_lambda/build_config.py

@@ -33,6 +33,7 @@ class AsyncLambdaBuildConfig:
         tls_version (Optional[str]): TLS version to use for the API.
         certificate_arn (Optional[str]): ARN of the SSL certificate for the domain.
         hosted_zone_id (Optional[str]): Hosted zone name for the Lambda/API.
+        auto_create_acm_certificate (bool): Whether or not to auto create a certificate in ACM for the domain name. Must be used in conjunction with hosted_zone_id and domain_name to be used.
 
     Methods:
         new(config: dict) -> AsyncLambdaBuildConfig:
@@ -55,6 +56,7 @@ class AsyncLambdaBuildConfig:
     tls_version: Optional[str] = None
     certificate_arn: Optional[str] = None
     hosted_zone_id: Optional[str] = None
+    auto_create_acm_certificate: Optional[bool] = None
 
     @classmethod
     def new(cls, config: dict) -> "AsyncLambdaBuildConfig":
@@ -94,6 +96,7 @@ class AsyncLambdaBuildConfig:
             tls_version=config.get("tls_version"),
             certificate_arn=config.get("certificate_arn"),
             hosted_zone_id=config.get("hosted_zone_id"),
+            auto_create_acm_certificate=config.get("auto_create_acm_certificate"),
         )
 
     def merge(self, other: "AsyncLambdaBuildConfig"):
@@ -113,6 +116,8 @@ class AsyncLambdaBuildConfig:
             self.certificate_arn = other.certificate_arn
         if other.hosted_zone_id is not None:
             self.hosted_zone_id = other.hosted_zone_id
+        if other.auto_create_acm_certificate is not None:
+            self.auto_create_acm_certificate = other.auto_create_acm_certificate
 
 
 def get_build_config_for_stage(

{async-lambda-unstable-0.5.7 → async_lambda_unstable-0.6.0}/async_lambda/controller.py

@@ -137,6 +137,7 @@ class AsyncLambdaController:
     current_task_id: Optional[str] = None
     current_lane: Optional[int] = None
     current_invocation_id: Optional[str] = None
+    _current_event_context: Optional[Any] = None
     parent_controller: Optional["AsyncLambdaController"] = None
     middleware: List[MiddlewareRegistration]
     delete_s3_payloads: bool = False
@@ -398,9 +399,10 @@ class AsyncLambdaController:
             if len(build_config.method_settings) > 0:
                 properties["MethodSettings"] = build_config.method_settings
             if build_config.domain_name is not None:
-                properties["Domain"] = {
+                domain_dict: dict = {
                     "DomainName": build_config.domain_name,
                 }
+                properties["Domain"] = domain_dict
                 if build_config.certificate_arn is not None:
                     properties["Domain"][
                         "CertificateArn"
@@ -409,10 +411,35 @@ class AsyncLambdaController:
                         properties["Domain"][
                             "SecurityPolicy"
                         ] = build_config.tls_version
+                elif (
+                    build_config.auto_create_acm_certificate is True
+                    and build_config.hosted_zone_id is not None
+                ):
+                    template["Resources"]["AsyncLambdaAPICertificate"] = {
+                        "Type": "AWS::CertificateManager::Certificate",
+                        "Properties": {
+                            "DomainName": build_config.domain_name,
+                            "ValidationMethod": "DNS",
+                            "DomainValidationOptions": [
+                                {
+                                    "DomainName": build_config.domain_name,
+                                    "HostedZoneId": build_config.hosted_zone_id,
+                                }
+                            ],
+                        },
+                    }
+                    properties["Domain"]["CertificateArn"] = {
+                        "Ref": "AsyncLambdaAPICertificate"
+                    }
+                    if build_config.tls_version is not None:
+                        properties["Domain"][
+                            "SecurityPolicy"
+                        ] = build_config.tls_version
                 if build_config.hosted_zone_id is not None:
-                    properties["Domain"]["Route53"] = {  # type: ignore
+                    properties["Domain"]["Route53"] = {
                         "HostedZoneId": build_config.hosted_zone_id
                     }
+
             template["Resources"]["AsyncLambdaAPIGateway"] = {
                 "Type": "AWS::Serverless::Api",
                 "Properties": properties,
@@ -497,6 +524,23 @@ class AsyncLambdaController:
             self.parent_controller.set_current_invocation_id(invocation_id)
         self.current_invocation_id = invocation_id
 
+    def set_current_event_context(self, context: Any):
+        """
+        Set the current event context on the parent controller.
+        """
+        if self.parent_controller is not None:
+            self.parent_controller.set_current_event_context(context)
+            return
+        self._current_event_context = context
+
+    def get_current_event_context(self) -> Any:
+        """
+        Get the current event context
+        """
+        if self.parent_controller is not None:
+            return self.parent_controller.get_current_event_context()
+        return self._current_event_context
+
     def handle_invocation(self, event, context, task_id: Optional[str] = None):
         """
         Handles the invocation of a task based on its trigger type.
@@ -525,6 +569,8 @@ class AsyncLambdaController:
 
         args = (event, context, task)
 
+        self.set_current_event_context(context)
+
         if task.trigger_type == TaskTriggerType.MANAGED_SQS:
             _event = ManagedSQSEvent(*args)
             lane_count = task.get_lane_count()
@@ -591,6 +637,7 @@ class AsyncLambdaController:
         delay: int = 0,
         force_sync: bool = False,
         lane: Optional[int] = None,
+        message_group_id: Optional[str] = None,
     ):
         """
         Sends an asynchronous invocation payload to a managed or external task via SQS.
@@ -621,6 +668,7 @@ class AsyncLambdaController:
                 delay=delay,
                 force_sync=force_sync,
                 lane=lane,
+                message_group_id=message_group_id,
             )
         is_external_task = False
         if destination_task_id not in self.tasks:
@@ -667,6 +715,7 @@ class AsyncLambdaController:
             # Sync invocation with mock event/context
             current_task_id = self.current_task_id
             current_lane = self.get_current_lane()
+            current_context = self.get_current_event_context()
             queue_arn = destination_task.get_managed_queue_arn(lane=lane)
             mock_event = MockSQSLambdaEvent(
                 json.dumps(sqs_payload), source_queue_arn=queue_arn
@@ -677,6 +726,7 @@ class AsyncLambdaController:
             )
             self.set_current_task_id(current_task_id)
             self.set_current_lane(current_lane)
+            self.set_current_event_context(current_context)
             return result
         else:
             if is_external_task:
@@ -684,10 +734,15 @@ class AsyncLambdaController:
             else:
                 assert destination_task is not None
                 url = destination_task.get_managed_queue_url(lane=lane)
+
+            _kwargs = {}
+            if message_group_id is not None:
+                _kwargs["MessageGroupId"] = message_group_id
             get_sqs_client().send_message(
                 QueueUrl=url,
                 MessageBody=json.dumps(sqs_payload),
                 DelaySeconds=delay,
+                **_kwargs,
             )
 
     def send_async_invoke_payload_batch(
@@ -932,6 +987,7 @@ class AsyncLambdaController:
         delay: int = 0,
         force_sync: bool = False,
         lane: Optional[int] = None,
+        message_group_id: Optional[str] = None,
     ):
         """
         Asynchronously invokes a task by sending a payload to the specified destination.
@@ -960,6 +1016,7 @@ class AsyncLambdaController:
             delay=delay,
             force_sync=force_sync,
             lane=lane,
+            message_group_id=message_group_id,
         )
 
     def async_invoke_batch(

{async-lambda-unstable-0.5.7 → async_lambda_unstable-0.6.0}/pyproject.toml

@@ -1,5 +1,6 @@
 [build-system]
-requires = ["setuptools<68.0.0", "wheel"]
+requires = ["hatchling>=1.25"]
+build-backend = "hatchling.build"
 
 [project]
 name = "async-lambda-unstable"
@@ -15,11 +16,29 @@ local = ["boto3", "flask>=2.3.0,<3.0.0"]
 [project.scripts]
 async-lambda = "async_lambda.cli:cli"
 
-[tool.setuptools.dynamic]
-version = { attr = "async_lambda.__version__" }
+[tool.hatch.version]
+path = "async_lambda/__init__.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["async_lambda"]
+
+[tool.hatch.build.targets.sdist]
+include = [
+  "async_lambda/**",
+  "pyproject.toml",
+  "README.md",
+  "LICENSE",
+]
+# (optional) extra excludes for safety
+exclude = [
+  "tests/**",
+  ".github/**",
+  "docs/**",
+  "examples/**",
+  "scripts/**",
+  "*.ipynb",
+]
 
-[tool.setuptools.package-data]
-"async_lambda" = ["py.typed"]
 
 [tool.pytest.ini_options]
 minversion = "6.0"

async-lambda-unstable-0.5.7/async_lambda_unstable.egg-info/PKG-INFO

@@ -1,438 +0,0 @@
-Metadata-Version: 2.1
-Name: async-lambda-unstable
-Version: 0.5.7
-Summary: A framework for creating AWS Lambda Async Workflows. - Unstable Branch
-Author-email: "Nuclei, Inc" <engineering@nuclei.ai>
-Description-Content-Type: text/markdown
-Provides-Extra: local
-
-# async-lambda
-
-Async-lambda is a Python framework for building scalable, event-driven AWS Lambda applications with first-class support for asynchronous invocation via SQS queues. It provides a high-level abstraction for orchestrating Lambda functions, managing event triggers, and handling complex workflows with minimal boilerplate.
-
-`async-lambda` converts your application into a `Serverless Application Model (SAM)`
-template which can be deployed with the `SAM` cli tool or via Cloudformation.
-
-## Features
-
-- **Async Task Abstraction**: Define tasks as Lambda functions triggered by SQS, API Gateway, DynamoDB Streams, or scheduled events.
-- **Automatic SAM Template Generation**: Converts your application into a Serverless Application Model (SAM) template for deployment.
-- **Lane-based Parallelism**: Scale async tasks horizontally using multiple SQS queues (lanes) and control concurrency per lane.
-- **Middleware Support**: Register middleware to wrap task execution, enabling cross-cutting concerns (logging, auth, etc.).
-- **Large Payload Handling**: Offload large payloads to S3 automatically when exceeding SQS size limits.
-- **Dead Letter Queues (DLQ)**: Robust error handling and message redrive for failed async invocations.
-- **Configurable via Code and JSON**: Set configuration at the app, stage, and task level using Python or config files.
-- **Task Initialization**: Run custom logic during Lambda INIT phase for caching, setup, or resource allocation.
-
-## Getting Started
-
-### Installation
-
-Add async-lambda to your project (see requirements in `pyproject.toml`).
-
-### Basic Usage
-
-```python
-from async_lambda import AsyncLambdaController, config_set_name, ScheduledEvent, ManagedSQSEvent
-
-app = AsyncLambdaController()
-config_set_name("project-name")
-lambda_handler = app.async_lambda_handler  # Required Lambda export
-
-@app.scheduled_task('ScheduledTask1', schedule_expression="rate(15 minutes)")
-def scheduled_task_1(event: ScheduledEvent):
-    app.async_invoke("AsyncTask1", payload={"foo": "bar"})
-
-@app.async_task('AsyncTask1')
-def async_task_2(event: ManagedSQSEvent):
-    print(event.payload)  # {"foo": "bar"}
-```
-
-### Packaging & Deployment
-
-Use the async-lambda CLI to build and package your app:
-
-```bash
-async-lambda build app --stage <stage-name>
-```
-
-This generates a SAM template (`template.json`) and deployment bundle (`deployment.zip`). Deploy using AWS SAM CLI or CloudFormation.
-
-## Core Concepts
-
-### Controller & Tasks
-
-- **AsyncLambdaController**: Central orchestrator for registering tasks, managing middleware, and handling invocations.
-- **Task**: Each task is a Lambda function with a unique `task_id` and a trigger type (SQS, API, DynamoDB, schedule).
-
-#### Task Decorators
-
-All task decorators accept common configuration arguments:
-- `memory`: Memory allocation (MB)
-- `timeout`: Timeout (seconds)
-- `ephemeral_storage`: Ephemeral storage (MB)
-- `maximum_concurrency`: Max concurrency for SQS triggers (int or list per lane)
-- `lane_count`: Number of parallel lanes (for async tasks)
-- `init_tasks`: Functions to run during Lambda INIT phase
-
-#### Example: Async Task
-
-```python
-@app.async_task("TaskID")
-def async_task(event: ManagedSQSEvent):
-    print(event.payload)
-```
-
-
-**It is quite easy to get into infinite looping situations when utilizing `async-lambda` and care should be taken.**
-
-**INFINITE LOOP EXAMPLE**
-
-```python
-# If task_1 where to ever get invoked, then it would start an infinite loop with
-# task 1 invoking task 2, task 2 invoking task 1, and repeat...
-
-@app.async_task("Task1")
-def task_1(event: ManagedSQSEvent):
-    app.async_invoke("Task2", {})
-
-@app.async_task("Task2")
-def task_1(event: ManagedSQSEvent):
-    app.async_invoke("Task1", {})
-```
-
-#### Example: Scheduled Task
-
-```python
-@app.scheduled_task("TaskID", schedule_expression='rate(15 minutes)')
-def scheduled_task(event: ScheduledEvent):
-    ...
-```
-
-#### Example: API Task
-
-```python
-@app.api_task("TaskID", path='/test', method='get')
-def api_task(event: APIEvent):
-    print(event.headers)
-    print(event.querystring_params)
-    print(event.body)
-```
-
-#### Example: Unmanaged SQS Task
-
-```python
-@app.sqs_task("TaskID", queue_arn='queue-arn')
-def sqs_task(event: UnmanagedSQSEvent):
-    print(event.body)
-```
-
-### Lanes & Concurrency
-
-Async tasks can be scaled horizontally using lanes. Each lane is a separate SQS queue and can have its own concurrency limit. Lane assignment can be controlled at the controller, sub-controller, or task level.
-
-```python
-app = AsyncLambdaController(lane_count=2)
-
-@app.async_task("SwitchBoard")
-def switch_board(event: ManagedSQSEvent):
-    lane = 1 if event.payload['value'] > 50000 else 0
-    app.async_invoke("ProcessingTask", event.payload, lane=lane)
-
-@app.async_task("ProcessingTask", maximum_concurrency=[10, 2])
-def processing_task(event: ManagedSQSEvent):
-    ...
-```
-
-### Middleware
-
-Middleware functions wrap task execution and can be used for logging, authentication, or modifying events/responses.
-
-```python
-def async_lambda_middleware(event, call_next):
-    print(f"Invocation Payload: {event}")
-    result = call_next(event)
-    print(f"Invocation Result: {result}")
-    return result
-
-controller = AsyncLambdaController(middleware=[([BaseEvent], async_lambda_middleware)])
-```
-
-If there are multiple middleware functions then `call_next` will actually be calling the next middleware function in the stack.
-
-For example if there is middleware functions `A` and `B` registered in that order.
-Then the execution order would go:
-
-`A(Pre)` -> `B(Pre)` -> `Task` -> `B(Post)` -> `A(Post)`
-
-### Large Payloads
-
-If a payload exceeds SQS size limits, async-lambda automatically stores it in S3 and passes a reference key to the Lambda function.
-
-### Dead Letter Queues (DLQ)
-
-All async tasks share a DLQ for failed messages. You can configure custom DLQ tasks for advanced error handling.
-
-## async-lambda config
-
-Configuration options can be set with the `.async_lambda/config.json` file.
-The configuration options can be set at the app, stage, and task level. A configuration option set
-will apply unless overridden at a more specific level (app -> stage -> task -> stage).
-The override logic attempts to be non-destructive so if you have a `layers` of `['layer_1']` at the app level,
-and `[layer_2]` at the stage level, then the value will be `['layer_1', 'layer_2']`.
-
-**Config file levels schema**
-
-```
-{
-    # APP LEVEL
-    "stages": {
-        "stage_name": {
-            # STAGE LEVEL
-        }
-    },
-    "tasks": {
-        "task_id": {
-            # TASK LEVEL
-            "stages": {
-                "stage_name": {
-                    # TASK STAGE LEVEL
-                }
-            }
-        }
-    }
-}
-```
-
-**At any of these `levels` any of the configuration options can be set:**
-With the exception of `domain_name`, `tls_version`, and `certificate_arn` which can not be set at the task level.
-
-### environment_variables
-
-```
-{
-    "ENV_VAR_NAME": "ENV_VAR_VALUE"
-}
-```
-
-This config value will set environment variables for the function execution.
-These environment variables will also be available during build time.
-
-[The value is passed to the `Environment` property on `SAM::Serverless::Function`](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html#sam-function-environment)
-
-### policies
-
-```
-[
-    'IAM_POLICY_ARN' | STATEMENT
-]
-```
-
-Use this config option to attach any arbitrary policies to the lambda functions execution role.
-
-[The value is passed to the `Policies` property on `SAM::Serverless::Function`](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html#sam-function-policies), in addition to the `async-lambda` created inline policies.
-
-### layers
-
-```
-[
-    "LAYER_ARN"
-]
-```
-
-Use this config option to add any arbitrary lambda layers to the lambda functions. Ordering matters,
-and merging is done thru concatenation.
-
-[The value is passed to the `Layers` property on `SAM::Serverless::Function`](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html#sam-function-layers)
-
-### subnet_ids
-
-```
-[
-    "SUBNET_ID"
-]
-```
-
-Use this config option to put the lambda function into a vpc/subnet.
-
-The value is passed into the [`SubnetIds`](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lambda-function-vpcconfig.html) field of the [`VpcConfig` property on `SAM::Serverless::Function`](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html#sam-function-vpcconfig)
-
-### security_group_ids
-
-```
-[
-    "SECURITY_GROUP_ID"
-]
-```
-
-Use this config option to attach a security group to the lambda function.
-
-The value is passed into the [`SecurityGroupIds`](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lambda-function-vpcconfig.html) field of the [`VpcConfig` property on `SAM::Serverless::Function`](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html#sam-function-vpcconfig)
-
-### managed_queue_extras
-
-```
-[
-    {
-        # Cloudformation resource
-    }
-]
-```
-
-Use this config option to add extra resources for managed SQS queues (`async_task` tasks.)
-
-For example this might be used to attach alarms to these queues.
-
-Each item in the list should be a complete cloudformation resource. `async-lambda` provides a few custom substitutions
-so that you can reference the extras and the associated managed sqs resource by `LogicalId`.
-
-- `$QUEUEID` will be replaced with the `LogicalId` of the associated Managed SQS queue.
-- `$EXTRA<index>` will be replaced with the `LogicalId` of the extra at the specified index.
-
-### method_settings
-
-**This config value can only be set at the app or stage level.**
-
-```
-[
-    {...}
-]
-```
-
-If your `async-lambda` app contains any `api_task` tasks, then a `AWS::Serverless::Api` resource is created.
-
-The value is passed into the [`MethodSettings`](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-api.html#sam-api-methodsettings) property of the `AWS::Serverless::Api`. The spec for `MethodSetting` can be found [here](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-apigateway-stage-methodsetting.html).
-
-### domain_name
-
-**This config value can only be set at the app or stage level.**
-
-```
-"domain_name"
-```
-
-If your `async-lambda` app contains any `api_task` tasks, then a `AWS::Serverless::Api` resource is created.
-
-This config value will set the [`DomainName`](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-property-api-domainconfiguration.html) field of the [`Domain` property](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-api.html#sam-api-domain)
-
-### tls_version
-
-**This config value can only be set at the app or stage level.**
-
-```
-"tls_version"
-```
-
-If your `async-lambda` app contains any `api_task` tasks, then a `AWS::Serverless::Api` resource is created.
-
-This config value will set the [`SecurityPolicy`](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-property-api-domainconfiguration.html) field of the [`Domain` property](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-api.html#sam-api-domain)
-
-Possible values are `TLS_1_0` and `TLS_1_2`
-
-### certificate_arn
-
-**This config value can only be set at the app or stage level.**
-
-```
-"certificate_arn"
-```
-
-If your `async-lambda` app contains any `api_task` tasks, then a `AWS::Serverless::Api` resource is created.
-
-This config value will set the [`CertificateArn`](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-property-api-domainconfiguration.html) field of the [`Domain` property](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-api.html#sam-api-domain)
-
-### hosted_zone_id
-
-**This config value can only be set at the app or stage level.**
-
-```
-"hosted_zone_id"
-```
-
-If your `async-lambda` app contains any `api_task` tasks, then a `AWS::Serverless::Api` resource is created.
-
-This config value will set the [`HostedZoneId`](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-property-api-domainconfiguration.html) field of the [`Route53`](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-property-api-domainconfiguration.html#sam-api-domainconfiguration-route53) property of the  [`Domain` property](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-api.html#sam-api-domain).
-
-This will create a DNS record on the given hosted zone for the api gateway endpoint created by the SAM deployment.
-
-### tags
-
-```
-{
-    "TAG_NAME": "TAG_VALUE"
-}
-```
-
-This config value will set the `Tags` field of all resources created by async-lambda. This will not set the field on `managed_queue_extras` resources.
-
-The keys `framework` and `framework-version` will always be set and the system values will override any values set by the user.
-
-For managed queues the tags `async-lambda-queue-type` will be set to `dlq`, `dlq-task`, or `managed` depending on the queue type.
-
-For `async_task` queues (non dlq-task) the `async-lambda-lane` will be set.
-
-### logging_config
-
-```
-{
-    "ApplicationLogLevel": "TRACE" | "DEBUG" | "INFO" | "WARN" | "ERROR" | "FATAL",
-    "LogFormat": "Text" | "JSON",
-    "LogGroup": "",
-    "SystemLogLevel": "DEBUG" | "INFO" | "WARN"
-}
-```
-
-The value is passed directly to the [`LoggingConfig`](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-function.html#cfn-lambda-function-loggingconfig) Cloudformation parameter for lambda function/s.
-
-See above for full details on configuration schema and merging behavior.
-
-## Advanced Usage
-
-### Task Initialization
-
-Use the `init_tasks` argument to run setup logic during Lambda INIT phase. This is useful for caching, resource allocation, or one-time setup.
-
-```python
-def setup_cache(task_id):
-    ...
-
-@app.async_task("TaskID", init_tasks=[setup_cache])
-def async_task(event: ManagedSQSEvent):
-    ...
-```
-
-### Defer Utility
-
-The `Defer` class allows you to cache values during INIT and only execute a function when its value is requested.
-
-```python
-cache = Defer(get_a_value, 10, 100)
-
-@app.async_task("Task", init_tasks=[cache.execute])
-def task(event: ManagedSQSEvent):
-    for i in range(cache.value):
-        ...
-```
-
-## Known Limitations
-
-- Not all Lambda configuration options are supported (see code for extension points)
-- Payloads must be JSON serializable
-- Infinite loops are possible if tasks invoke each other recursively
-
-## Project Structure
-
-- `async_lambda/`: Core framework code
-    - `controller.py`: Main controller and orchestration logic
-    - `models/`: Event, response, and task models
-    - `middleware.py`: Middleware registration and execution
-    - `client.py`, `env.py`, `config.py`: AWS clients and configuration
-    - `defer.py`: Defer utility for caching
-    - `payload_encoder.py`, `util.py`: Utilities
-- `example/`: Example usage and sample app
-- `scripts/`: Linting and testing scripts
-- `test/`: Unit tests
-
-## License
-
-See LICENSE file for details.

async-lambda-unstable-0.5.7/async_lambda_unstable.egg-info/SOURCES.txt

@@ -1,34 +0,0 @@
-README.md
-pyproject.toml
-async_lambda/__init__.py
-async_lambda/build_config.py
-async_lambda/cli.py
-async_lambda/client.py
-async_lambda/config.py
-async_lambda/controller.py
-async_lambda/defer.py
-async_lambda/env.py
-async_lambda/middleware.py
-async_lambda/payload_encoder.py
-async_lambda/py.typed
-async_lambda/util.py
-async_lambda/models/__init__.py
-async_lambda/models/api_response.py
-async_lambda/models/case_insensitive_dict.py
-async_lambda/models/task.py
-async_lambda/models/events/__init__.py
-async_lambda/models/events/api_event.py
-async_lambda/models/events/base_event.py
-async_lambda/models/events/dynamodb_event.py
-async_lambda/models/events/managed_sqs_batch_event.py
-async_lambda/models/events/managed_sqs_event.py
-async_lambda/models/events/scheduled_event.py
-async_lambda/models/events/unmanaged_sqs_event.py
-async_lambda/models/mock/mock_context.py
-async_lambda/models/mock/mock_event.py
-async_lambda_unstable.egg-info/PKG-INFO
-async_lambda_unstable.egg-info/SOURCES.txt
-async_lambda_unstable.egg-info/dependency_links.txt
-async_lambda_unstable.egg-info/entry_points.txt
-async_lambda_unstable.egg-info/requires.txt
-async_lambda_unstable.egg-info/top_level.txt

async-lambda-unstable-0.5.7/async_lambda_unstable.egg-info/dependency_links.txt

@@ -1 +0,0 @@
-

async-lambda-unstable-0.5.7/async_lambda_unstable.egg-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-async-lambda = async_lambda.cli:cli

async-lambda-unstable-0.5.7/async_lambda_unstable.egg-info/requires.txt

@@ -1,6 +0,0 @@
-click>=8.0.0
-typing-extensions>=4.0.0
-
-[local]
-boto3
-flask<3.0.0,>=2.3.0

async-lambda-unstable-0.5.7/async_lambda_unstable.egg-info/top_level.txt

@@ -1 +0,0 @@
-async_lambda

async-lambda-unstable-0.5.7/setup.cfg

@@ -1,4 +0,0 @@
-[egg_info]
-tag_build = 
-tag_date = 0
-