modmex-lambda 0.2.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

modmex_lambda/__init__.py

@@ -7,51 +7,60 @@ from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
     from .event_handler import (
-        ApiGatewayHttpResolver,
-        ApiGatewayRestResolver,
+        APIGatewayHttpResolver,
+        APIGatewayRestResolver,
         Response,
     )
     from .event_handler.request import Request
     from .event_sources import event_source
-    from .event_handler.dependencies.depends import (
+    from .connectors import AwsConnectorsModule
+    from .dependencies import (
         DefaultDependencyResolver,
         DependencyResolver,
-        Depends,
         InjectorDependencyResolver,
+        create_dependency_resolver,
+        default_dependency_resolver,
     )
+    from .event_handler.dependencies.depends import Depends
     from .logging import Logger
     from .parser import event_parser, parse
     from .validation import ModmexValidator, ValidationError
 
 _EXPORTS = {
-    "ApiGatewayHttpResolver": ("modmex_lambda.event_handler", "ApiGatewayHttpResolver"),
-    "ApiGatewayRestResolver": ("modmex_lambda.event_handler", "ApiGatewayRestResolver"),
+    "APIGatewayHttpResolver": ("modmex_lambda.event_handler", "APIGatewayHttpResolver"),
+    "APIGatewayRestResolver": ("modmex_lambda.event_handler", "APIGatewayRestResolver"),
     "Request": ("modmex_lambda.event_handler.request", "Request"),
     "Response": ("modmex_lambda.event_handler", "Response"),
     "parse": ("modmex_lambda.parser", "parse"),
     "event_parser": ("modmex_lambda.parser", "event_parser"),
     "event_source": ("modmex_lambda.event_sources", "event_source"),
-    "DefaultDependencyResolver": ("modmex_lambda.event_handler.dependencies.depends", "DefaultDependencyResolver"),
-    "DependencyResolver": ("modmex_lambda.event_handler.dependencies.depends", "DependencyResolver"),
+    "AwsConnectorsModule": ("modmex_lambda.connectors", "AwsConnectorsModule"),
+    "DefaultDependencyResolver": ("modmex_lambda.dependencies", "DefaultDependencyResolver"),
+    "DependencyResolver": ("modmex_lambda.dependencies", "DependencyResolver"),
     "Depends": ("modmex_lambda.event_handler.dependencies.depends", "Depends"),
-    "InjectorDependencyResolver": ("modmex_lambda.event_handler.dependencies.depends", "InjectorDependencyResolver"),
+    "InjectorDependencyResolver": ("modmex_lambda.dependencies", "InjectorDependencyResolver"),
+    "create_dependency_resolver": ("modmex_lambda.dependencies", "create_dependency_resolver"),
+    "default_dependency_resolver": ("modmex_lambda.dependencies", "default_dependency_resolver"),
     "Logger": ("modmex_lambda.logging", "Logger"),
     "ModmexValidator": ("modmex_lambda.validation", "ModmexValidator"),
     "ValidationError": ("modmex_lambda.validation", "ValidationError"),
 }
 
 __all__ = [
-    "ApiGatewayHttpResolver",
-    "ApiGatewayRestResolver",
+    "APIGatewayHttpResolver",
+    "APIGatewayRestResolver",
     "Request",
     "Response",
     "parse",
     "event_parser",
     "event_source",
+    "AwsConnectorsModule",
     "DefaultDependencyResolver",
     "DependencyResolver",
     "Depends",
     "InjectorDependencyResolver",
+    "create_dependency_resolver",
+    "default_dependency_resolver",
     "Logger",
     "ModmexValidator",
     "ValidationError",

modmex_lambda/connectors/__init__.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from importlib import import_module
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from modmex_lambda.connectors.module import AwsConnectorsModule
+
+_EXPORTS = {
+    "AwsConnectorsModule": ("modmex_lambda.connectors.module", "AwsConnectorsModule"),
+}
+
+__all__ = ["AwsConnectorsModule"]
+
+
+def __getattr__(name: str) -> Any:
+    target = _EXPORTS.get(name)
+    if target is None:
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+    module_name, attr = target
+    value = getattr(import_module(module_name), attr)
+    globals()[name] = value
+    return value
+
+
+def __dir__() -> list[str]:
+    return sorted([*globals().keys(), *__all__])

modmex_lambda/connectors/cloudwatch.py

@@ -0,0 +1,17 @@
+from modmex_lambda.connectors.icloudwatch import ICloudWatchConnector
+
+
+class Connector(ICloudWatchConnector):
+
+    def __init__(self, client = None) -> None:
+        self._client = client
+
+    @property
+    def client(self):
+        if not self._client:
+            import boto3
+            self._client = boto3.client('cloudwatch')
+        return self._client
+
+    def put(self, input_params):
+        return self.client.put_metric_data(**input_params)

modmex_lambda/connectors/dynamodb.py

@@ -0,0 +1,123 @@
+from functools import reduce
+from typing import Iterable
+
+from modmex_lambda.connectors.idynamodb import IDynamodbConnector
+from modmex_lambda.stream.utils.retry import (
+    assert_max_retries,
+    DEFAULT_RETRY_CONFIG,
+    wait,
+    get_delay
+)
+
+
+class Connector(IDynamodbConnector):
+
+    def __init__(self,# pylint: disable=W0102
+                 table_name = 'undefined',
+                 retry_config = DEFAULT_RETRY_CONFIG,
+                 client = None) -> None:
+        self.table_name = table_name
+        self._client = client
+        self.retry_config = retry_config
+
+    @property
+    def client(self):
+        if not self._client:
+            import boto3
+            self._client = boto3.resource('dynamodb')
+        return self._client
+
+    def get(self, input_params):
+        return  self.client.Table(self.table_name).get_item(
+            **input_params
+        )
+
+    def update(self, input_params):
+        return  self.client.Table(self.table_name).update_item(
+            **input_params
+        )
+
+    def put(self, input_params):
+        return  self.client.Table(self.table_name).put_item(
+            **input_params
+        )
+
+    def query(self, input_params):
+        return  self.client.Table(self.table_name).query(
+            **input_params
+        )
+
+    def query_page(self, input_params):
+        return self.query(input_params)
+
+    def scan(self, input_params):
+        return self.client.Table(self.table_name).scan(
+            **input_params
+        )
+
+    def query_all(self, input_params):
+        items = []
+        while True:
+
+            result = self.client.Table(self.table_name).query(
+                **input_params
+            )
+            for item in result['Items']:
+                items.append(item)
+
+            if 'LastEvaluatedKey' in result and result['LastEvaluatedKey']:
+                input_params['ExclusiveStartKey'] = result['LastEvaluatedKey']
+            else:
+                break
+        return items
+
+    def batch_get(self, input_params):
+        return self._batch_get(input_params, [])
+
+    def _batch_get(self, params, attempts):
+        assert_max_retries(attempts, self.retry_config['max_retries'])
+        wait(get_delay(self.retry_config['retry_wait'], len(attempts)))
+        resp = self.client.batch_get_item(**params)
+        if 'UnprocessedKeys' in resp and resp['UnprocessedKeys']:
+            return self._batch_get(
+                unprocessed(params, resp),
+                [*attempts, resp]
+            )
+        return accumulate(attempts, resp)
+
+    def bulk_insert(self, items: Iterable):
+        with self.client.Table(self.table_name).batch_writer() as batch:
+            for item in items:
+                batch.put_item(Item=item)
+
+    def bulk_delete(self, items: Iterable):
+        with self.client.Table(self.table_name).batch_writer() as batch:
+            for key in items:
+                batch.delete_item(Key=key)
+
+
+def unprocessed(params, resp):
+    return {
+        **params,
+        'RequestItems': resp['UnprocessedKeys']
+    }
+
+def accumulate(attempts, resp):
+    def reducer(a, c):
+        return {
+            **a,
+            'Responses': reduce(
+                lambda a2, c2: {
+                    **a2,
+                    c2: [
+                        *a2.get(c2, []),
+                        *a['Responses'].get(c2, [])
+                    ]
+                },
+                list(a['Responses']),
+                {**c['Responses']}
+            ),
+            'attempts': [*attempts, resp]
+        }
+
+    return reduce(reducer, reversed(attempts), resp)

modmex_lambda/connectors/eventbridge.py

@@ -0,0 +1,19 @@
+
+from modmex_lambda.connectors.ieventbridge import IEventBridgeConnector
+
+
+class Connector(IEventBridgeConnector):
+
+    def __init__(self, client = None) -> None:
+        self._client = client
+
+    @property
+    def client(self):
+        if not self._client:
+            import boto3
+            self._client = boto3.client('events')
+        return self._client
+
+    def put_events(self, params):
+        response = self.client.put_events(**params)
+        return response

modmex_lambda/connectors/icloudwatch.py

@@ -0,0 +1,14 @@
+from abc import ABC, abstractmethod
+from typing import Any, Dict
+
+
+class ICloudWatchConnector(ABC):
+    @property
+    def client(self) -> Any:
+        """Returns the CloudWatch client"""
+        raise NotImplementedError("client property must be implemented")
+
+    @abstractmethod
+    def put(self, input_params: Dict[str, Any]) -> Dict[str, Any]:
+        """Puts metric data into CloudWatch"""
+        raise NotImplementedError("put method must be implemented")

modmex_lambda/connectors/idynamodb.py

@@ -0,0 +1,68 @@
+from abc import ABC, abstractmethod
+from typing import Any, Dict, Iterable
+
+class IDynamodbConnector(ABC):
+    table_name: str
+    retry_config: Dict[str, Any]
+
+    @property
+    def client(self) -> Any:
+        """Returns the DynamoDB resource"""
+        raise NotImplementedError("client property must be implemented")
+
+    @abstractmethod
+    def get(self, input_params: Dict[str, Any]) -> Dict[str, Any]:
+        """Retrieves an item from the table"""
+        raise NotImplementedError("get method must be implemented")
+
+    @abstractmethod
+    def update(self, input_params: Dict[str, Any]) -> Dict[str, Any]:
+        """Updates an item in the table"""
+        raise NotImplementedError("update method must be implemented")
+
+    @abstractmethod
+    def put(self, input_params: Dict[str, Any]) -> Dict[str, Any]:
+        """Puts an item into the table"""
+        raise NotImplementedError("put method must be implemented")
+
+    @abstractmethod
+    def query(self, input_params: Dict[str, Any]) -> Dict[str, Any]:
+        """Queries items from the table"""
+        raise NotImplementedError("query method must be implemented")
+
+    @abstractmethod
+    def query_all(self, input_params: Dict[str, Any]) -> list[Dict[str, Any]]:
+        """Queries all items, handling pagination"""
+        raise NotImplementedError("query_all method must be implemented")
+
+    @abstractmethod
+    def query_page(self, input_params: Dict[str, Any]) -> Dict[str, Any]:
+        """Queries one page of items"""
+        raise NotImplementedError("query_page method must be implemented")
+
+    @abstractmethod
+    def scan(self, input_params: Dict[str, Any]) -> Dict[str, Any]:
+        """Scans one page of items"""
+        raise NotImplementedError("scan method must be implemented")
+
+    @abstractmethod
+    def batch_get(self, input_params: Dict[str, Any]) -> Dict[str, Any]:
+        """Performs a batch get operation"""
+        raise NotImplementedError("batch_get method must be implemented")
+
+    @abstractmethod
+    def bulk_insert(self, items: Iterable[Dict[str, Any]]) -> None:
+        """Inserts multiple items using batch writer"""
+        raise NotImplementedError("bulk_insert method must be implemented")
+
+    @abstractmethod
+    def bulk_delete(self, items: Iterable[Dict[str, Any]]) -> None:
+        """Deletes multiple items using batch writer"""
+        raise NotImplementedError("bulk_delete method must be implemented")
+
+
+class DynamoDbResource(ABC):
+
+    @abstractmethod
+    def Table(self, name: str):
+        raise NotImplementedError()

modmex_lambda/connectors/ieventbridge.py

@@ -0,0 +1,14 @@
+from abc import ABC, abstractmethod
+from typing import Any, Dict
+
+class IEventBridgeConnector(ABC):
+    
+    @property
+    def client(self) -> Any:
+        """Returns the EventBridge client"""
+        raise NotImplementedError("client property must be implemented")
+
+    @abstractmethod
+    def put_events(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """Puts events into EventBridge"""
+        raise NotImplementedError("put_events method must be implemented")

modmex_lambda/connectors/ilambda.py

@@ -0,0 +1,14 @@
+from abc import ABC, abstractmethod
+from typing import Any, Dict
+
+
+class ILambdaConnector(ABC):
+    @property
+    def client(self) -> Any:
+        """Returns the Lambda client"""
+        raise NotImplementedError("client property must be implemented")
+
+    @abstractmethod
+    def invoke(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """Invokes a Lambda function"""
+        raise NotImplementedError("invoke method must be implemented")

modmex_lambda/connectors/is3.py

@@ -0,0 +1,30 @@
+from abc import ABC, abstractmethod
+from typing import Any, Dict
+
+class IS3Connector(ABC):
+    bucket_name: str
+
+    @property
+    def client(self) -> Any:
+        """Returns the S3 client"""
+        raise NotImplementedError("client property must be implemented")
+
+    @abstractmethod
+    def put_object(self, input_params: Dict[str, Any]) -> Dict[str, Any]:
+        """Uploads an object to the bucket"""
+        raise NotImplementedError("put_object method must be implemented")
+
+    @abstractmethod
+    def get_object(self, input_params: Dict[str, Any]) -> Dict[str, Any]:
+        """Retrieves an object from the bucket"""
+        raise NotImplementedError("get_object method must be implemented")
+
+    @abstractmethod
+    def list_objects(self, input_params: Dict[str, Any]) -> Dict[str, Any]:
+        """Lists objects in the bucket"""
+        raise NotImplementedError("list_objects method must be implemented")
+
+    @abstractmethod
+    def delete_object(self, input_params: Dict[str, Any]) -> Dict[str, Any]:
+        """Deletes an object from the bucket"""
+        raise NotImplementedError("delete_object method must be implemented")

modmex_lambda/connectors/isns.py

@@ -0,0 +1,20 @@
+from abc import ABC, abstractmethod
+from typing import Any, Dict
+
+class ISNSConnector(ABC):
+    topic_arn: str
+
+    @property
+    def client(self) -> Any:
+        """Returns the SNS client"""
+        raise NotImplementedError("client property must be implemented")
+
+    @abstractmethod
+    def publish(self, input_params: Dict[str, Any]) -> Dict[str, Any]:
+        """Publishes a message to the SNS topic"""
+        raise NotImplementedError("publish method must be implemented")
+
+    @abstractmethod
+    def publish_batch(self, input_params: Dict[str, Any]) -> Dict[str, Any]:
+        """Publishes a batch of messages to the SNS topic"""
+        raise NotImplementedError("publish_batch method must be implemented")

modmex_lambda/connectors/isqs.py

@@ -0,0 +1,21 @@
+from abc import ABC, abstractmethod
+from typing import Any, Dict
+
+
+class ISQSConnector(ABC):
+    queue_url: str
+
+    @property
+    def client(self) -> Any:
+        """Returns the SQS client"""
+        raise NotImplementedError("client property must be implemented")
+
+    @abstractmethod
+    def send_message(self, input_params: Dict[str, Any]) -> Dict[str, Any]:
+        """Sends a message to SQS"""
+        raise NotImplementedError("send_message method must be implemented")
+
+    @abstractmethod
+    def send_message_batch(self, input_params: Dict[str, Any]) -> Dict[str, Any]:
+        """Sends a message batch to SQS"""
+        raise NotImplementedError("send_message_batch method must be implemented")

modmex_lambda/connectors/lambda_.py

@@ -0,0 +1,17 @@
+from modmex_lambda.connectors.ilambda import ILambdaConnector
+
+
+class Connector(ILambdaConnector):
+
+    def __init__(self, client = None) -> None:
+        self._client = client
+
+    @property
+    def client(self):
+        if not self._client:
+            import boto3
+            self._client = boto3.client('lambda')
+        return self._client
+
+    def invoke(self, params):
+        return self.client.invoke(**params)

modmex_lambda/connectors/module.py

@@ -0,0 +1,67 @@
+"""Injector module with default AWS connector bindings."""
+
+from __future__ import annotations
+
+from injector import Module, provider, singleton
+
+from modmex_lambda.connectors.icloudwatch import ICloudWatchConnector
+from modmex_lambda.connectors.idynamodb import IDynamodbConnector
+from modmex_lambda.connectors.ieventbridge import IEventBridgeConnector
+from modmex_lambda.connectors.ilambda import ILambdaConnector
+from modmex_lambda.connectors.is3 import IS3Connector
+from modmex_lambda.connectors.isns import ISNSConnector
+from modmex_lambda.connectors.isqs import ISQSConnector
+
+
+class AwsConnectorsModule(Module):
+    @singleton
+    @provider
+    def provide_dynamodb(self) -> IDynamodbConnector:
+        from modmex_lambda.connectors.dynamodb import Connector
+
+        return Connector()
+
+    @singleton
+    @provider
+    def provide_cloudwatch(self) -> ICloudWatchConnector:
+        from modmex_lambda.connectors.cloudwatch import Connector
+
+        return Connector()
+
+    @singleton
+    @provider
+    def provide_eventbridge(self) -> IEventBridgeConnector:
+        from modmex_lambda.connectors.eventbridge import Connector
+
+        return Connector()
+
+    @singleton
+    @provider
+    def provide_lambda(self) -> ILambdaConnector:
+        from modmex_lambda.connectors.lambda_ import Connector
+
+        return Connector()
+
+    @singleton
+    @provider
+    def provide_s3(self) -> IS3Connector:
+        from modmex_lambda.connectors.s3 import Connector
+
+        return Connector(None)
+
+    @singleton
+    @provider
+    def provide_sns(self) -> ISNSConnector:
+        from modmex_lambda.connectors.sns import Connector
+
+        return Connector()
+
+    @singleton
+    @provider
+    def provide_sqs(self) -> ISQSConnector:
+        from modmex_lambda.connectors.sqs import Connector
+
+        return Connector()
+
+
+__all__ = ["AwsConnectorsModule"]

modmex_lambda/connectors/s3.py

@@ -0,0 +1,43 @@
+from modmex_lambda.connectors.is3 import IS3Connector
+
+
+class Connector(IS3Connector):
+
+    def __init__(self, bucket_name, client = None) -> None:
+        self.bucket_name = bucket_name
+        self._client = client
+
+    @property
+    def client(self):
+        if not self._client:
+            import boto3
+            self._client = boto3.client('s3')
+        return self._client
+
+    def put_object(self, input_params):
+        params = {
+            'Bucket': self.bucket_name,
+            **input_params
+        }
+        return self.client.put_object(**params)
+
+    def get_object(self, input_params):
+        params = {
+            'Bucket': self.bucket_name,
+            **input_params
+        }
+        return self.client.get_object(**params)
+
+    def list_objects(self, input_params):
+        params = {
+            'Bucket': self.bucket_name,
+            **input_params
+        }
+        return self.client.list_objects_v2(**params)
+
+    def delete_object(self, input_params):
+        params = {
+            'Bucket': self.bucket_name,
+            **input_params
+        }
+        return self.client.delete_object(**params)

modmex_lambda/connectors/sns.py

@@ -0,0 +1,31 @@
+import os
+
+from modmex_lambda.connectors.isns import ISNSConnector
+from modmex_lambda.stream.utils.aws import get_region
+
+
+class Connector(ISNSConnector):
+    def __init__(self, topic_arn = os.getenv('TOPIC_ARN'), client = None) -> None:
+        self.topic_arn = topic_arn
+        self._client = client
+
+    @property
+    def client(self):
+        if not self._client:
+            import boto3
+            self._client = boto3.client('sns', region_name=get_region(self.topic_arn))
+        return self._client
+
+    def publish(self, input_params):
+        params = {
+            'TopicArn': self.topic_arn,
+            **input_params
+        }
+        return self.client.publish(**params)
+
+    def publish_batch(self, input_params):
+        params = {
+            'TopicArn': self.topic_arn,
+            **input_params
+        }
+        return self.client.publish_batch(**params)

modmex_lambda/connectors/sqs.py

@@ -0,0 +1,31 @@
+import os
+from modmex_lambda.connectors.isqs import ISQSConnector
+
+
+class Connector(ISQSConnector):
+
+    def __init__(self, queue_url = os.getenv('QUEUE_URL'), client = None) -> None:
+        self.queue_url = queue_url
+        self._client = client
+
+    @property
+    def client(self):
+        if not self._client:
+            import boto3
+            self._client = boto3.client('sqs')
+        return self._client
+
+    def send_message(self, input_params):
+        params = {
+            'QueueUrl': self.queue_url,
+            **input_params
+        }
+
+        return self.client.send_message(**params)
+
+    def send_message_batch(self, input_params):
+        params = {
+            'QueueUrl': self.queue_url,
+            **input_params
+        }
+        return self.client.send_message_batch(**params)