async-lambda-unstable 0.3.9__tar.gz → 0.3.11__tar.gz

{async-lambda-unstable-0.3.9 → async-lambda-unstable-0.3.11}/PKG-INFO

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

@@ -5,10 +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.9"
+__version__ = "0.3.11"

{async-lambda-unstable-0.3.9 → async-lambda-unstable-0.3.11}/async_lambda/controller.py

@@ -529,7 +529,15 @@ class AsyncLambdaController:
 
         return _task
 
-    def dynamodb_task(self, task_id: str, *, stream_arn: str, batch_size: int):
+    def dynamodb_task(
+        self,
+        task_id: str,
+        *,
+        stream_arn: str,
+        batch_size: int,
+        max_batching_window: int = 0,
+        **kwargs,
+    ):
         """
         Decorate a function to register it as a DynamoDB task.
         These tasks will be triggered by the given DynamoDB stream.
@@ -550,7 +558,12 @@ class AsyncLambdaController:
                     executable=inner,
                     task_id=task_id,
                     trigger_type=TaskTriggerType.DYNAMODB_EVENT,
-                    trigger_config={"stream_arn": stream_arn, "batch_size": batch_size},
+                    trigger_config={
+                        "stream_arn": stream_arn,
+                        "batch_size": batch_size,
+                        "max_batching_window": max_batching_window,
+                    },
+                    **kwargs,
                 )
             )
 

async-lambda-unstable-0.3.11/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.9 → async-lambda-unstable-0.3.11}/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.9 → async-lambda-unstable-0.3.11}/async_lambda/models/task.py

@@ -273,6 +273,9 @@ class AsyncLambdaTask(Generic[EventType]):
                         "Stream": self.trigger_config["stream_arn"],
                         "StartingPosition": "TRIM_HORIZON",
                         "BatchSize": self.trigger_config["batch_size"],
+                        "MaximumBatchingWindowInSeconds": self.trigger_config[
+                            "max_batching_window"
+                        ],
                         "Enabled": True,
                     },
                 }

{async-lambda-unstable-0.3.9 → async-lambda-unstable-0.3.11}/async_lambda_unstable.egg-info/PKG-INFO

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

@@ -11,6 +11,7 @@ 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