async-lambda-unstable 0.3.8__tar.gz → 0.3.10__tar.gz

{async-lambda-unstable-0.3.8 → async-lambda-unstable-0.3.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: async-lambda-unstable
-Version: 0.3.8
+Version: 0.3.10
 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.3.8 → async-lambda-unstable-0.3.10}/async_lambda/__init__.py

@@ -5,9 +5,11 @@ from .defer import Defer as Defer
 from .env import disable_force_sync_mode as disable_force_sync_mode
 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.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.8"
+__version__ = "0.3.10"

{async-lambda-unstable-0.3.8 → async-lambda-unstable-0.3.10}/async_lambda/controller.py

@@ -11,6 +11,7 @@ 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.dynamodb_event import DynamoDBEvent
 from .models.events.managed_sqs_event import ManagedSQSEvent
 from .models.events.scheduled_event import ScheduledEvent
 from .models.events.unmanaged_sqs_event import UnmanagedSQSEvent
@@ -238,6 +239,8 @@ class AsyncLambdaController:
             _event = ScheduledEvent(*args)
         elif task.trigger_type == TaskTriggerType.API_EVENT:
             _event = APIEvent(*args)
+        elif task.trigger_type == TaskTriggerType.DYNAMODB_EVENT:
+            _event = DynamoDBEvent(*args)
         else:
             raise NotImplementedError(
                 f"Trigger type of {task.trigger_type} is not supported."
@@ -525,3 +528,32 @@ class AsyncLambdaController:
             return inner
 
         return _task
+
+    def dynamodb_task(self, task_id: str, *, stream_arn: str, batch_size: int):
+        """
+        Decorate a function to register it as a DynamoDB task.
+        These tasks will be triggered by the given DynamoDB stream.
+        """
+        logger.debug(
+            f"Registered dynamodb task '{task_id}' with stream_arn '{stream_arn}' and batch_size '{batch_size}' with the controller."
+        )
+
+        def _task(func: Callable[[DynamoDBEvent], Any]):
+            @functools.wraps(func)
+            def inner(*args, **kwargs):
+                self.set_current_task_id(task_id)
+                return func(*args, **kwargs)
+
+            self.add_task(
+                AsyncLambdaTask(
+                    controller=self,
+                    executable=inner,
+                    task_id=task_id,
+                    trigger_type=TaskTriggerType.DYNAMODB_EVENT,
+                    trigger_config={"stream_arn": stream_arn, "batch_size": batch_size},
+                )
+            )
+
+            return inner
+
+        return _task

async-lambda-unstable-0.3.10/async_lambda/models/case_insensitive_dict.py

@@ -0,0 +1,82 @@
+import collections.abc
+from collections import OrderedDict
+from typing import Tuple, TypeVar
+
+T = TypeVar("T", bound=str)
+V = TypeVar("V")
+
+
+class CaseInsensitiveDict(collections.abc.MutableMapping[T, V]):
+    """
+    A case-insensitive ``dict``-like object.
+
+    Implements all methods and operations of
+    ``MutableMapping`` as well as dict's ``copy``. Also
+    provides ``lower_items``.
+
+    All keys are expected to be strings. The structure remembers the
+    case of the last key to be set, and ``iter(instance)``,
+    ``keys()``, ``items()``, ``iterkeys()``, and ``iteritems()``
+    will contain case-sensitive keys. However, querying and contains
+    testing is case insensitive::
+
+        cid = CaseInsensitiveDict()
+        cid['Accept'] = 'application/json'
+        cid['aCCEPT'] == 'application/json'  # True
+        list(cid) == ['Accept']  # True
+
+    For example, ``headers['content-encoding']`` will return the
+    value of a ``'Content-Encoding'`` response header, regardless
+    of how the header name was originally stored.
+
+    If the constructor, ``.update``, or equality comparison
+    operations are given keys that have equal ``.lower()``s, the
+    behavior is undefined.
+
+    This was vendored from requests
+    https://github.com/kennethreitz/requests/blob/v2.25.1/requests/structures.py
+
+    Generic typing added by me.
+    """
+
+    def __init__(self, data=None, **kwargs):
+        self._store: OrderedDict[T, Tuple[T, V]] = OrderedDict()
+        if data is None:
+            data = {}
+        self.update(data, **kwargs)
+
+    def __setitem__(self, key, value):
+        # Use the lowercased key for lookups, but store the actual
+        # key alongside the value.
+        self._store[key.lower()] = (key, value)
+
+    def __getitem__(self, key):
+        return self._store[key.lower()][1]
+
+    def __delitem__(self, key):
+        del self._store[key.lower()]
+
+    def __iter__(self):
+        return (casedkey for casedkey, mappedvalue in self._store.values())
+
+    def __len__(self):
+        return len(self._store)
+
+    def lower_items(self):
+        """Like iteritems(), but with all lowercase keys."""
+        return ((lowerkey, keyval[1]) for (lowerkey, keyval) in self._store.items())
+
+    def __eq__(self, other):
+        if isinstance(other, collections.abc.Mapping):
+            other = CaseInsensitiveDict(other)
+        else:
+            return NotImplemented
+        # Compare insensitively
+        return dict(self.lower_items()) == dict(other.lower_items())
+
+    # Copy is required
+    def copy(self):
+        return CaseInsensitiveDict(self._store.values())
+
+    def __repr__(self):
+        return str(dict(self.items()))

{async-lambda-unstable-0.3.8 → async-lambda-unstable-0.3.10}/async_lambda/models/events/api_event.py

@@ -1,13 +1,14 @@
 from typing import Any, Dict, List, Optional
 
+from ..case_insensitive_dict import CaseInsensitiveDict
 from .base_event import BaseEvent
 
 
 class APIEvent(BaseEvent):
     path: str
     method: str
-    headers: Dict[str, str]
-    multi_value_headers: Dict[str, List[str]]
+    headers: CaseInsensitiveDict[str, str]
+    multi_value_headers: CaseInsensitiveDict[str, List[str]]
     querystring_params: Dict[str, str]
     multi_value_querystring_params: Dict[str, List[str]]
     path_parameters: Dict[str, str]
@@ -18,8 +19,8 @@ class APIEvent(BaseEvent):
     def _hydrate_event(self):
         self.path = self._event["path"]
         self.method = self._event["httpMethod"]
-        self.headers = self._event["headers"]
-        self.multi_value_headers = self._event["multiValueHeaders"]
+        self.headers = CaseInsensitiveDict(self._event["headers"])
+        self.multi_value_headers = CaseInsensitiveDict(self._event["multiValueHeaders"])
         self.querystring_params = self._event.get("queryStringParameters", dict())
         self.multi_value_querystring_params = self._event.get(
             "multiValueQueryStringParameters", dict()

async-lambda-unstable-0.3.10/async_lambda/models/events/dynamodb_event.py

@@ -0,0 +1,19 @@
+from typing import Optional
+
+from .base_event import BaseEvent
+
+
+class DynamoDBRecord(BaseEvent):
+    new_image: Optional[dict]
+    old_image: Optional[dict]
+
+    def _hydrate_event(self):
+        dynamodb_dict = self._event["dynamodb"]
+        self.new_image = dynamodb_dict.get("NewImage")
+        self.old_image = dynamodb_dict.get("OldImage")
+
+
+class DynamoDBEvent(BaseEvent):
+    def __iter__(self):
+        for record in self._event["Records"]:
+            yield DynamoDBRecord(record, self._context, self._task)

{async-lambda-unstable-0.3.8 → async-lambda-unstable-0.3.10}/async_lambda/models/task.py

@@ -13,6 +13,7 @@ from ..config import config
 if TYPE_CHECKING:
     from ..controller import AsyncLambdaController  # pragma: not covered
 
+from .events.dynamodb_event import DynamoDBEvent
 from .events.managed_sqs_event import ManagedSQSEvent
 from .events.scheduled_event import ScheduledEvent
 from .events.unmanaged_sqs_event import UnmanagedSQSEvent
@@ -23,10 +24,12 @@ class TaskTriggerType(Enum):
     UNMANAGED_SQS = 2
     SCHEDULED_EVENT = 3
     API_EVENT = 4
+    DYNAMODB_EVENT = 5
 
 
 EventType = TypeVar(
-    "EventType", bound=Union[ManagedSQSEvent, ScheduledEvent, UnmanagedSQSEvent]
+    "EventType",
+    bound=Union[ManagedSQSEvent, ScheduledEvent, UnmanagedSQSEvent, DynamoDBEvent],
 )
 
 
@@ -262,6 +265,18 @@ class AsyncLambdaTask(Generic[EventType]):
                     },
                 }
             }
+        elif self.trigger_type == TaskTriggerType.DYNAMODB_EVENT:
+            return {
+                "DynamoDBEvent": {
+                    "Type": "DynamoDB",
+                    "Properties": {
+                        "Stream": self.trigger_config["stream_arn"],
+                        "StartingPosition": "TRIM_HORIZON",
+                        "BatchSize": self.trigger_config["batch_size"],
+                        "Enabled": True,
+                    },
+                }
+            }
         raise NotImplementedError()
 
     def get_policy_sqs_resources(self) -> List[dict]:

{async-lambda-unstable-0.3.8 → async-lambda-unstable-0.3.10}/async_lambda_unstable.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: async-lambda-unstable
-Version: 0.3.8
+Version: 0.3.10
 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.3.8 → async-lambda-unstable-0.3.10}/async_lambda_unstable.egg-info/SOURCES.txt

@@ -11,10 +11,12 @@ async_lambda/env.py
 async_lambda/py.typed
 async_lambda/util.py
 async_lambda/models/__init__.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_event.py
 async_lambda/models/events/scheduled_event.py
 async_lambda/models/events/unmanaged_sqs_event.py