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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: async-lambda-unstable
-Version: 0.3.9
+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.9 → async-lambda-unstable-0.3.10}/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.10"

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.9 → 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.9 → 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.9
+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.9 → async-lambda-unstable-0.3.10}/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