async-lambda-unstable 0.4.3__tar.gz → 0.4.5__tar.gz

{async-lambda-unstable-0.4.3 → async-lambda-unstable-0.4.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: async-lambda-unstable
-Version: 0.4.3
+Version: 0.4.5
 Summary: A framework for creating AWS Lambda Async Workflows. - Unstable Branch
 Author-email: "Nuclei, Inc" <engineering@nuclei.ai>
 Description-Content-Type: text/markdown

{async-lambda-unstable-0.4.3 → async-lambda-unstable-0.4.5}/async_lambda/__init__.py

@@ -1,5 +1,6 @@
 from .config import config_set_name as config_set_name
 from .config import config_set_runtime as config_set_runtime
+from .config import config_set_s3_payload_retention as config_set_s3_payload_retention
 from .controller import AsyncLambdaController as AsyncLambdaController
 from .defer import Defer as Defer
 from .env import disable_force_sync_mode as disable_force_sync_mode
@@ -13,4 +14,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.4.3"
+__version__ = "0.4.5"

{async-lambda-unstable-0.4.3 → async-lambda-unstable-0.4.5}/async_lambda/config.py

@@ -1,6 +1,10 @@
+from typing import Optional
+
+
 class AsyncLambdaConfig:
     name: str = "async-lambda"
     runtime: str = "python3.10"
+    s3_payload_retention: Optional[int] = None
 
 
 config = AsyncLambdaConfig()
@@ -18,3 +22,10 @@ def config_set_runtime(runtime: str):
     Sets the runtime for the project.
     """
     config.runtime = runtime
+
+
+def config_set_s3_payload_retention(days: int):
+    """
+    Sets the s3_payload_retention policy in days.
+    """
+    config.s3_payload_retention = days

{async-lambda-unstable-0.4.3 → async-lambda-unstable-0.4.5}/async_lambda/controller.py

@@ -4,12 +4,13 @@ import logging
 import re
 import time
 from datetime import datetime, timezone
-from typing import Any, Callable, Dict, List, Optional, Tuple, Type
+from typing import Any, Callable, Dict, List, Optional, Type
 from uuid import uuid4
 
 from . import env
 from .build_config import get_build_config_for_stage
 from .client import get_s3_client, get_sqs_client
+from .config import config
 from .middleware import MET, RT, MiddlewareFunction, MiddlewareRegistration
 from .models.events.api_event import APIEvent
 from .models.events.base_event import BaseEvent
@@ -35,6 +36,8 @@ class AsyncLambdaController:
     current_invocation_id: Optional[str] = None
     parent_controller: Optional["AsyncLambdaController"] = None
     middleware: List[MiddlewareRegistration]
+    delete_s3_payloads: bool = True
+    controller_name: Optional[str] = None
 
     dlq_task_id: Optional[str] = None
 
@@ -44,14 +47,16 @@ class AsyncLambdaController:
         lane_count: Optional[int] = None,
         propagate_lane_assignment: Optional[bool] = None,
         middleware: Optional[List[MiddlewareRegistration]] = None,
-        exception_handler: Optional[Callable[[Exception], None]] = None,
+        delete_s3_payloads: bool = True,
+        controller_name: Optional[str] = None,
     ):
         self.tasks = dict()
         self.is_sub = is_sub
         self.lane_count = lane_count
         self.propagate_lane_assignment = propagate_lane_assignment
         self.middleware = middleware or list()
-        self.exception_handler = exception_handler
+        self.delete_s3_payloads = delete_s3_payloads
+        self.controller_name = controller_name
 
     def add_middleware(
         self, event_types: List[Type[BaseEvent]], func: MiddlewareFunction[MET, RT]
@@ -136,13 +141,27 @@ class AsyncLambdaController:
         Generates the SAM Template for this project.
         """
         build_config = get_build_config_for_stage(config_dict, stage)
+        s3_bucket_properties = {}
+        if config.s3_payload_retention:
+            s3_bucket_properties["LifecycleConfiguration"] = {
+                "Rules": [
+                    {
+                        "Id": f"Auto delete objects after {config.s3_payload_retention} days.",
+                        "ExpirationInDays": config.s3_payload_retention,
+                        "Status": "Enabled",
+                    }
+                ]
+            }
         template = {
             "AWSTemplateFormatVersion": "2010-09-09",
             "Transform": "AWS::Serverless-2016-10-31",
             "Resources": {
                 "AsyncLambdaPayloadBucket": {
                     "Type": "AWS::S3::Bucket",
-                    "Properties": {"Tags": make_cf_tags(build_config.tags)},
+                    "Properties": {
+                        "Tags": make_cf_tags(build_config.tags),
+                        **s3_bucket_properties,
+                    },
                 },
                 "AsyncLambdaDLQ": {
                     "Type": "AWS::SQS::Queue",
@@ -273,27 +292,31 @@ class AsyncLambdaController:
                 f"Trigger type of {task.trigger_type} is not supported."
             )
         response = task.execute(_event)
-        if isinstance(_event, ManagedSQSEvent) and _event.s3_payload_key is not None:
+        if (
+            isinstance(_event, ManagedSQSEvent)
+            and _event.s3_payload_key is not None
+            and self.delete_s3_payloads
+        ):
             get_s3_client().delete_object(
                 Bucket=env.get_payload_bucket(), Key=_event.s3_payload_key
             )
         return response
 
-    def _async_invoke(
+    def send_async_invoke_payload(
         self,
         destination_task_id: str,
-        payload: Any,
+        sqs_payload: dict,
         delay: Optional[int] = None,
         force_sync: bool = False,
         lane: Optional[int] = None,
     ):
         """
-        Invoke an 'async-lambda' task asynchronously utilizing it's SQS queue
+        Invoke an 'async-lambda' task asynchronously utilizing it's SQS queue.
         """
         if self.parent_controller is not None:
-            return self.parent_controller._async_invoke(
+            return self.parent_controller.send_async_invoke_payload(
                 destination_task_id=destination_task_id,
-                payload=payload,
+                sqs_payload=sqs_payload,
                 delay=delay,
                 force_sync=force_sync,
                 lane=lane,
@@ -319,21 +342,6 @@ class AsyncLambdaController:
                 f"Unable to invoke task {destination_task_id} in lane {lane} because it is not a valid lane for the task."
             )
 
-        if self.current_invocation_id is None:
-            invocation_id = str(uuid4())
-        else:
-            invocation_id = self.current_invocation_id
-
-        sqs_body, payload_size = self._prepare_async_payload(
-            payload=payload,
-            invocation_id=invocation_id,
-            destination_task_id=destination_task.task_id,
-            force_sync=force_sync or env.get_force_sync_mode(),
-        )
-
-        logger.info(
-            f"Invoking task '{destination_task.task_id}' - invocation_id '{invocation_id}' - delay {delay or 0} - size ({payload_size}) - lane {lane}"
-        )
         if force_sync or env.get_force_sync_mode():
             if delay:
                 time.sleep(delay)
@@ -347,27 +355,38 @@ class AsyncLambdaController:
                     and current_task.trigger_type == TaskTriggerType.MANAGED_SQS
                 ):
                     queue_arn = current_task.get_managed_queue_arn(lane=lane)
-            mock_event = MockSQSLambdaEvent(sqs_body, source_queue_arn=queue_arn)
+            mock_event = MockSQSLambdaEvent(
+                json.dumps(sqs_payload), source_queue_arn=queue_arn
+            )
             mock_context = MockLambdaContext(destination_task.task_id)
-            response = self.handle_invocation(
+            result = self.handle_invocation(
                 mock_event, mock_context, task_id=destination_task_id
             )
             self.set_current_task_id(current_task_id)
-            return response
+            return result
         else:
             get_sqs_client().send_message(
                 QueueUrl=destination_task.get_managed_queue_url(lane=lane),
-                MessageBody=sqs_body,
+                MessageBody=json.dumps(sqs_payload),
                 DelaySeconds=delay,
             )
 
-    def _prepare_async_payload(
+    def new_payload(
         self,
         payload: Any,
-        invocation_id: str,
         destination_task_id: str,
         force_sync: bool,
-    ) -> Tuple[str, int]:
+    ) -> dict:
+        if self.parent_controller is not None:
+            return self.parent_controller.new_payload(
+                payload=payload,
+                destination_task_id=destination_task_id,
+                force_sync=force_sync,
+            )
+        if self.current_invocation_id is None:
+            invocation_id = str(uuid4())
+        else:
+            invocation_id = self.current_invocation_id
         raw_sqs_body = {
             "source_task_id": self.current_task_id,
             "destination_task_id": destination_task_id,
@@ -391,7 +410,7 @@ class AsyncLambdaController:
         else:
             raw_sqs_body["payload"] = serialized_payload
 
-        return json.dumps(raw_sqs_body), payload_size
+        return raw_sqs_body
 
     def add_controller(self, controller: "AsyncLambdaController"):
         controller.parent_controller = self
@@ -409,9 +428,12 @@ class AsyncLambdaController:
         """
         Invoke an Async-Lambda task.
         """
-        return self._async_invoke(
+        sqs_payload = self.new_payload(
+            payload=payload, destination_task_id=task_id, force_sync=force_sync
+        )
+        return self.send_async_invoke_payload(
             destination_task_id=task_id,
-            payload=payload,
+            sqs_payload=sqs_payload,
             delay=delay,
             force_sync=force_sync,
             lane=lane,

{async-lambda-unstable-0.4.3 → async-lambda-unstable-0.4.5}/async_lambda_unstable.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: async-lambda-unstable
-Version: 0.4.3
+Version: 0.4.5
 Summary: A framework for creating AWS Lambda Async Workflows. - Unstable Branch
 Author-email: "Nuclei, Inc" <engineering@nuclei.ai>
 Description-Content-Type: text/markdown