async-lambda-unstable 0.3.12__tar.gz → 0.4.1__tar.gz

{async-lambda-unstable-0.3.12 → async-lambda-unstable-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: async-lambda-unstable
-Version: 0.3.12
+Version: 0.4.1
 Summary: A framework for creating AWS Lambda Async Workflows. - Unstable Branch
 Author-email: "Nuclei, Inc" <engineering@nuclei.ai>
 Description-Content-Type: text/markdown
@@ -186,8 +186,50 @@ def api_task(event: APIEvent):
     event.headers # request headers
     event.querystring_params # request querystring params
     event.body # request body
+    event.headers # This is a case insensitive dict
 ```
 
+# Middleware
+
+Middleware functions can be registered with controllers which will execute before the task code is run.
+These functions can be configured to trigger on specific types of tasks and can modify the `event`.
+
+Middleware functions must have the signature `Callable[[BaseEvent], BaseEvent]`.
+Middleware functions are run in the order which they were registered and parent controller middleware will be run first.
+Middleware functions which are registered more than once will only be run once.
+
+Registration can be done when the `AsyncLambdaController` is initialized with the parameter `middleware` or by using the `add_middleware` method.
+
+EX:
+
+```python
+def async_task_only_middleware(event: ManagedSQSEvent):
+    print(f"Invocation Payload: {event}")
+    return event
+
+def all_task_types_middleware(event: BaseEvent):
+    print(f"This task is of the type {type(event)}")
+    return event
+
+controller = AsyncLambdaController(middleware=[([BaseEvent], all_task_types_middleware)])
+
+controller.add_middleware([ManagedSQSEvent], async_task_only_middleware)
+
+@controller.async_task("ATask")
+def a_task(event: ManagedSQSEvent):
+    pass
+
+@controller.api_task("BTask", "/test", "get")
+def b_task(event: APIEvent):
+    return "hello world"
+```
+
+In this scenario when `ATask` is invoked first `all_task_types_middleware` will be run, then
+`async_task_only_middleware` will be run and finally the `a_task` function will be executed.
+
+When `BTask` is invoked first `all_task_types_middleware` will be run, and then the `b_task`
+function will be executed
+
 # `async-lambda` config
 
 Configuration options can be set with the `.async_lambda/config.json` file.

{async-lambda-unstable-0.3.12 → async-lambda-unstable-0.4.1}/README.md

@@ -178,8 +178,50 @@ def api_task(event: APIEvent):
     event.headers # request headers
     event.querystring_params # request querystring params
     event.body # request body
+    event.headers # This is a case insensitive dict
 ```
 
+# Middleware
+
+Middleware functions can be registered with controllers which will execute before the task code is run.
+These functions can be configured to trigger on specific types of tasks and can modify the `event`.
+
+Middleware functions must have the signature `Callable[[BaseEvent], BaseEvent]`.
+Middleware functions are run in the order which they were registered and parent controller middleware will be run first.
+Middleware functions which are registered more than once will only be run once.
+
+Registration can be done when the `AsyncLambdaController` is initialized with the parameter `middleware` or by using the `add_middleware` method.
+
+EX:
+
+```python
+def async_task_only_middleware(event: ManagedSQSEvent):
+    print(f"Invocation Payload: {event}")
+    return event
+
+def all_task_types_middleware(event: BaseEvent):
+    print(f"This task is of the type {type(event)}")
+    return event
+
+controller = AsyncLambdaController(middleware=[([BaseEvent], all_task_types_middleware)])
+
+controller.add_middleware([ManagedSQSEvent], async_task_only_middleware)
+
+@controller.async_task("ATask")
+def a_task(event: ManagedSQSEvent):
+    pass
+
+@controller.api_task("BTask", "/test", "get")
+def b_task(event: APIEvent):
+    return "hello world"
+```
+
+In this scenario when `ATask` is invoked first `all_task_types_middleware` will be run, then
+`async_task_only_middleware` will be run and finally the `a_task` function will be executed.
+
+When `BTask` is invoked first `all_task_types_middleware` will be run, and then the `b_task`
+function will be executed
+
 # `async-lambda` config
 
 Configuration options can be set with the `.async_lambda/config.json` file.

{async-lambda-unstable-0.3.12 → async-lambda-unstable-0.4.1}/async_lambda/__init__.py

@@ -7,9 +7,10 @@ from .env import enable_force_sync_mode as enable_force_sync_mode
 from .env import is_build_mode as is_build_mode
 from .models.case_insensitive_dict import CaseInsensitiveDict as CaseInsensitiveDict
 from .models.events.api_event import APIEvent as APIEvent
+from .models.events.base_event import BaseEvent as BaseEvent
 from .models.events.dynamodb_event import DynamoDBEvent as DynamoDBEvent
 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.3.12"
+__version__ = "0.4.1"

{async-lambda-unstable-0.3.12 → async-lambda-unstable-0.4.1}/async_lambda/controller.py

@@ -4,13 +4,14 @@ import logging
 import re
 import time
 from datetime import datetime, timezone
-from typing import Any, Callable, Dict, Optional, Tuple
+from typing import Any, Callable, Dict, List, Optional, Tuple, Type, TypeVar
 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 .models.events.api_event import APIEvent
+from .models.events.base_event import BaseEvent
 from .models.events.dynamodb_event import DynamoDBEvent
 from .models.events.managed_sqs_event import ManagedSQSEvent
 from .models.events.scheduled_event import ScheduledEvent
@@ -22,6 +23,11 @@ from .util import make_cf_tags
 
 logger = logging.getLogger(__name__)
 
+MET = TypeVar("MET", bound=BaseEvent)
+
+MiddlewareFunction = Callable[[MET], MET]
+MiddlewareRegistration = Tuple[List[Type[MET]], MiddlewareFunction[MET]]
+
 
 class AsyncLambdaController:
     is_sub: bool
@@ -32,6 +38,7 @@ class AsyncLambdaController:
     current_lane: Optional[int] = None
     current_invocation_id: Optional[str] = None
     parent_controller: Optional["AsyncLambdaController"] = None
+    middleware: List[MiddlewareRegistration]
     dlq_task_id: Optional[str] = None
 
     def __init__(
@@ -39,11 +46,33 @@ class AsyncLambdaController:
         is_sub: bool = False,
         lane_count: Optional[int] = None,
         propagate_lane_assignment: Optional[bool] = None,
+        middleware: Optional[List[MiddlewareRegistration]] = 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()
+
+    def add_middleware(
+        self, event_types: List[Type[BaseEvent]], func: MiddlewareFunction[MET]
+    ):
+        self.middleware.append((event_types, func))
+
+    def execute_middleware(
+        self, event: MET, _ran_fns: Optional[List[Callable]] = None
+    ) -> Tuple[MET, List[Callable]]:
+        if _ran_fns is None:
+            _ran_fns = list()
+        if self.parent_controller is not None:
+            event, _ran_fns = self.parent_controller.execute_middleware(event, _ran_fns)
+        for event_types, func in self.middleware:
+            if func in _ran_fns:
+                continue
+            if any(isinstance(event, event_type) for event_type in event_types):
+                event = func(event)
+                _ran_fns.append(func)
+        return event, _ran_fns
 
     def add_task(self, task: AsyncLambdaTask):
         """

{async-lambda-unstable-0.3.12 → async-lambda-unstable-0.4.1}/async_lambda/models/task.py

@@ -486,4 +486,5 @@ class AsyncLambdaTask(Generic[EventType]):
         Executes the tasks function
         """
         self._run_init_tasks()
+        self.controller.execute_middleware(event)
         return self.executable(event)

{async-lambda-unstable-0.3.12 → async-lambda-unstable-0.4.1}/async_lambda_unstable.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: async-lambda-unstable
-Version: 0.3.12
+Version: 0.4.1
 Summary: A framework for creating AWS Lambda Async Workflows. - Unstable Branch
 Author-email: "Nuclei, Inc" <engineering@nuclei.ai>
 Description-Content-Type: text/markdown
@@ -186,8 +186,50 @@ def api_task(event: APIEvent):
     event.headers # request headers
     event.querystring_params # request querystring params
     event.body # request body
+    event.headers # This is a case insensitive dict
 ```
 
+# Middleware
+
+Middleware functions can be registered with controllers which will execute before the task code is run.
+These functions can be configured to trigger on specific types of tasks and can modify the `event`.
+
+Middleware functions must have the signature `Callable[[BaseEvent], BaseEvent]`.
+Middleware functions are run in the order which they were registered and parent controller middleware will be run first.
+Middleware functions which are registered more than once will only be run once.
+
+Registration can be done when the `AsyncLambdaController` is initialized with the parameter `middleware` or by using the `add_middleware` method.
+
+EX:
+
+```python
+def async_task_only_middleware(event: ManagedSQSEvent):
+    print(f"Invocation Payload: {event}")
+    return event
+
+def all_task_types_middleware(event: BaseEvent):
+    print(f"This task is of the type {type(event)}")
+    return event
+
+controller = AsyncLambdaController(middleware=[([BaseEvent], all_task_types_middleware)])
+
+controller.add_middleware([ManagedSQSEvent], async_task_only_middleware)
+
+@controller.async_task("ATask")
+def a_task(event: ManagedSQSEvent):
+    pass
+
+@controller.api_task("BTask", "/test", "get")
+def b_task(event: APIEvent):
+    return "hello world"
+```
+
+In this scenario when `ATask` is invoked first `all_task_types_middleware` will be run, then
+`async_task_only_middleware` will be run and finally the `a_task` function will be executed.
+
+When `BTask` is invoked first `all_task_types_middleware` will be run, and then the `b_task`
+function will be executed
+
 # `async-lambda` config
 
 Configuration options can be set with the `.async_lambda/config.json` file.