nimble-aws 0.1.0__tar.gz

nimble_aws-0.1.0/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.1
+Name: nimble-aws
+Version: 0.1.0
+Summary: 
+Author: Lucas Tiense Blazzi
+Author-email: lucast.blazzi@gmail.com
+Requires-Python: >=3.11,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: aiobotocore (==2.13.1)
+Requires-Dist: boto3 (>=1.17.47,<2.0.0)
+Requires-Dist: pydantic (>=2.4.2,<3.0.0)
+Requires-Dist: pydantic-settings (>=2.0.3,<3.0.0)
+Description-Content-Type: text/markdown
+
+

nimble_aws-0.1.0/nimble_aws/adapter/api_gateway.py

@@ -0,0 +1,38 @@
+import json
+
+from .config import env
+from .session import Session
+
+
+class ApiGateway(Session):
+    
+    async def post_to_connection(self, connection_id, data, region=env.region):
+        """
+        Send a message to a client's WebSocket connection.
+        :param connection_id: The ID of the connection.
+        :param data: The message to send.
+        :param region: The region of the connection (default: us-east-1).
+        :return: The response from the API Gateway Management API.
+        """
+        session = await self.session
+        async with session.create_client("apigatewaymanagementapi", region_name=region) as client:
+            response = await client.post_to_connection(
+                ConnectionId=connection_id, 
+                Data=json.dumps(data).encode("utf-8")
+            )
+            return response
+    
+    async def get_api_key(self, api_key_id, region=env.region):
+        """
+        Get an API key.
+        :param api_key_id: The ID of the API key
+        :param region: The region of the API key (default: us-east-1).
+        :return: The response from the API Gateway API.
+        """
+        session = await self.session
+        async with session.create_client("apigateway", region_name=region) as client:
+            response = await client.get_api_key(
+                apiKey=api_key_id,
+                includeValue=True
+            )
+            return response

nimble_aws-0.1.0/nimble_aws/adapter/appsync.py

@@ -0,0 +1,51 @@
+from .config import env
+from .session import Session
+
+
+class AppSync(Session):
+    
+    async def list_keys(self, api_id, max_results=10, region=env.region):
+        """
+        List API keys.
+        :param api_id: The ID of the API.
+        :param max_results: The maximum number of results to return (default: 10).
+        :param region: The region of the API (default: us-east-1).
+        :return: The response from the AppSync API.
+        """
+        session = await self.session
+        async with session.create_client(service_name="appsync", region_name=region) as client:
+            response = await client.list_api_keys(
+                apiId=api_id,
+                maxResults=max_results
+            )
+            return response
+        
+    async def get_key(self, api_id, key_id, region=env.region):
+        """
+        Get an API key.service_name=
+        :param api_id: The ID of the API.
+        :param key_id: The ID of the key.
+        :param region: The region of the API (default: us-east-1).
+        :return: The value of the provided API key id.
+        """
+        session = await self.session
+        async with session.create_client(service_name="appsync", region_name=region) as client:
+            response = await client.list_api_keys(
+                apiId=api_id,
+                maxResults=100
+            )
+            api_key = next((key["id"] for key in response["apiKeys"] if key["id"] == key_id), response["apiKeys"][0]["id"])
+            return api_key
+        
+    async def get_domain(self, api_id, region=env.region):
+        """
+        Get the domain name of an API.
+        :param api_id: The ID of the API.
+        :param region: The region of the API (default: us-east-1).
+        :return: The domain name of the API.
+        """
+        session = await self.session
+        async with session.create_client(service_name="appsync", region_name=region) as client:
+            response = await client.list_graphql_apis()
+            domain_name = next((domain["uris"]["GRAPHQL"] for domain in response["graphqlApis"] if domain["apiId"] == api_id), None)
+            return domain_name

nimble_aws-0.1.0/nimble_aws/adapter/cognito.py

@@ -0,0 +1,19 @@
+from .config import env
+from .session import Session
+
+
+class Cognito(Session):
+    
+    async def get_user(self, auth, region=env.region):
+        """
+        Get a user.
+        :param auth: The user's authentication token.
+        :param region: The region of the user (default: us-east-1).
+        :return: The response from the Cognito Identity Provider API.
+        """
+        session = await self.session
+        async with session.create_client(service_name="cognito-idp", region_name=region) as client:
+            response = await client.get_user(
+                AccessToken=auth
+            )
+            return response

nimble_aws-0.1.0/nimble_aws/adapter/config.py

@@ -0,0 +1,10 @@
+from pydantic import Field
+from pydantic_settings import BaseSettings
+from typing import Optional
+
+
+class Environment(BaseSettings):
+    region: Optional[str] = Field(default="us-east-1", alias="REGION")
+
+
+env = Environment()

nimble_aws-0.1.0/nimble_aws/adapter/dynamodb.py

@@ -0,0 +1,193 @@
+import json
+import asyncio
+from decimal import Decimal
+
+from functional import seq
+from boto3.dynamodb.types import TypeDeserializer, TypeSerializer
+
+from .config import env
+from .session import Session
+
+
+serializer = TypeSerializer()
+deserializer = TypeDeserializer()
+
+
+class DynamoDB(Session):
+    
+    @staticmethod
+    def preprocess_item(item):
+        item = json.loads(json.dumps(item), parse_float=Decimal)
+        try:
+            item = {k: serializer.serialize(v) for k, v in item.items()}
+        except AttributeError:
+            return serializer.serialize(item)
+    
+    @staticmethod
+    def process_item(item):
+        return {k: serializer.serialize(v) for k, v in item.items()}
+    
+    async def describe_table(self, table_name, region=env.region):
+        """
+        Describe a DynamoDB table.
+        :param table_name: The name of the table.
+        :param region: The region of the table (default: us-east-1).
+        :return: The response from the DynamoDB API.
+        """
+        
+        session = await self.session
+        async with session.create_client(service_name="dynamodb", region_name=region) as client:
+            response = await client.describe_table(
+                TableName=table_name
+            )
+        return response
+        
+    async def put_items(self, table_name, items, region=env.region):
+        """
+        Put items into a DynamoDB table.
+        :param table_name: The name of the table.
+        :param items: The items to put.
+        :param region: The region of the table (default: us-east-1).
+        :return: The response from the DynamoDB API.
+        """
+        
+        session = await self.session
+        async with session.create_client(service_name="dynamodb", region_name=region) as client:
+            tasks = [client.put_item(
+                TableName=table_name,
+                Item=self.preprocess_item(item)
+            ) for item in items]
+            result = await asyncio.gather(*tasks)
+        return result
+    
+    async def delete_items(self, table_name, id_list, region=env.region):
+        """
+        Delete items from a DynamoDB table.
+        :param table_name: The name of the table.
+        :param id_list: The IDs of the items to delete.
+        :param region: The region of the table (default: us-east-1).
+        :return: The response from the DynamoDB API.
+        """
+        
+        session = await self.session
+        async with session.create_client(service_name="dynamodb", region_name=region) as client:
+            tasks = [client.delete_item(
+                TableName=table_name,
+                Key=self.preprocess_item(id)
+            ) for id in id_list]
+            result = await asyncio.gather(*tasks)
+        return result
+    
+    async def get_item(self, table_name, id, region=env.region):
+        """
+        Get an item from a DynamoDB table.
+        :param table_name: The name of the table.
+        :param id: The ID of the item to get.
+        :param region: The region of the table (default: us-east-1).
+        :return: The serialized item from the DynamoDB API.
+        """
+        
+        session = await self.session
+        async with session.create_client(service_name="dynamodb", region_name=region) as client:
+            response = await client.get_item(
+                TableName=table_name,
+                Key=self.preprocess_item(id)
+            )
+            result = self.process_item(response.get("Item", {}))
+        return result
+    
+    async def get_items(self, table_name, id_list, region=env.region):
+        """
+        Get many items from a DynamoDB table.
+        :param table_name: The name of the table.
+        :param id_list: The IDs of the items to get.
+        :param region: The region of the table (default: us-east-1).
+        :return: The serialized items from the DynamoDB API.
+        """
+        
+        session = await self.session
+        async with session.create_client(service_name="dynamodb", region_name=region) as client:
+            tasks = [client.get_item(
+                TableName=table_name,
+                Key=self.preprocess_item(id)
+            ) for id in id_list]
+            response = await asyncio.gather(*tasks)
+            result = [self.process_item(item.get("Item", {})) for item in response]
+        return result
+    
+    async def index_query(self, table_mname, index, filters, region=env.region, **kwargs):
+        """
+        Get many items from a DynamoDB table using an index.
+        :param table_mname: The name of the table.
+        :param index: The index definition to query (example: {"name": "metadata-index", "field": "metadata", "value": "audio"}).
+        :param filters: The filters to apply (example: {"deleted": false}).
+        :param region: The region of the table (default: us-east-1).
+        :param kwargs: Additional arguments to pass to the DynamoDB API.
+        :return: The serialized items from the DynamoDB API.
+        """
+        
+        filters.update({index["field"]: index["value"]})
+        expression_attr = self.preprocess_item({f":{k}": filters[k] for k in filters.keys()})
+        
+        session = await self.session
+        async with session.create_client(service_name="dynamodb", region_name=region) as client:
+            response = await client.query(
+                TableName=table_mname,
+                IndexName=index["name"],
+                KeyConditionExpression=f"#{index['field']} = :{index['field']}",
+                ExpressionAttributeNames={f"#{index['field']}": index["field"]},
+                ExpressionAttributeValues=expression_attr,
+                **kwargs
+            )
+            result = [self.process_item(item) for item in response.get("Items", [])]
+        return result
+    
+    async def scan_dynamo(self, table_name, region=env.region):
+        """
+        Scan a DynamoDB table.
+        :param table_name: The name of the table.
+        :param region: The region of the table (default: us-east-1).
+        :return: The serialized items from the DynamoDB API
+        """
+        
+        session = await self.session
+        async with session.create_client(service_name="dynamodb", region_name=region) as client:
+            response = await client.scan(
+                TableName=table_name
+            )
+            result = list(seq(response.get("Items", [])).map(self.process_item))
+            while "LastEvaluatedKey" in response:
+                response = await client.scan(
+                    TableName=table_name,
+                    ExclusiveStartKey=response["LastEvaluatedKey"]
+                )
+                result.extend(list(seq(response.get("Items", [])).map(self.process_item)))
+        return result
+    
+    async def update_items(self, table_name, items, key_fields, region=env.region):
+        """
+        Update items in a DynamoDB table.
+        :param table_name: The name of the table.
+        :param items: The items to update.
+        :param key_fields: The fields to use as keys.
+        :param region: The region of the table (default: us-east-1).
+        :return: The serialized new items from the DynamoDB API.
+        """
+        
+        items = [self.preprocess_item(item) for item in items]
+        
+        session = await self.session
+        async with session.create_client(service_name="dynamodb", region_name=region) as client:
+            tasks = [client.update_item(
+                TableName=table_name,
+                Key={k: item.pop(k) for k in key_fields},
+                ReturnValues="ALL_NEW",
+                AttributeValues={
+                    **{k: {
+                        "Action": "PUT",
+                        "Value": v,
+                    } for k, v in item.items()}}
+            ) for item in items]
+            response = await asyncio.gather(*tasks)
+            result = [self.process_item(item.get("Attributes", {})) for item in response]
+        return result

nimble_aws-0.1.0/nimble_aws/adapter/event_bridge.py

@@ -0,0 +1,26 @@
+import asyncio
+
+from .config import env
+from .session import Session
+
+
+class EventBridge(Session):
+    
+    async def publish_events(self, messages, batch_size=10, region=env.region):
+        """
+        Publish events to an EventBridge bus.
+        :param messages: The messages to publish.
+        :param batch_size: The number of messages to publish at a time (default: 10).
+        :param region: The region of the bus (default: us-east-1).
+        :return: The response from the EventBridge API.
+        """        
+
+        chunks = [messages[i:i + batch_size] for i in range(0, len(messages), batch_size)]
+        
+        session = await self.session
+        async with session.create_client(service_name="events", region_name=region) as client:
+            tasks = [client.put_events(
+                Entries=chunk
+            ) for chunk in chunks]
+            result = await asyncio.gather(*tasks)
+        return result

nimble_aws-0.1.0/nimble_aws/adapter/glue.py

@@ -0,0 +1,51 @@
+import asyncio
+
+from .config import env
+from .session import Session
+
+
+class Glue(Session):
+    
+    async def get_jobs(self, region=env.region):
+        """
+        Get a list of jobs.
+        :param region: The region of the jobs (default: us-east-1).
+        :return: The response from the Glue API.
+        """
+        session = await self.session
+        async with session.create_client(service_name="glue", region_name=region) as client:
+            response = await client.get_jobs()
+        return response
+    
+    async def get_job_runs(self, job_name, max_results, region=env.region):
+        """
+        Get a list of job runs.
+        :param job_name: The name of the job.
+        :param max_results: The maximum number of results to return.
+        :param region: The region of the job (default: us-east-1).
+        :return: The response from the Glue API.
+        """
+        session = await self.session
+        async with session.create_client(service_name="glue", region_name=region) as client:
+            response = await client.get_job_runs(
+                JobName=job_name,
+                MaxResults=max_results
+            )
+        return response
+    
+    async def get_jobs_runs(self, job_names, max_results, region=env.region):
+        """
+        Get a list of job runs for multiple jobs.
+        :param job_names: The names of the jobs.
+        :param max_results: The maximum number of results to return.
+        :param region: The region of the jobs (default: us-east-1).
+        :return: The response from the Glue API.
+        """
+        session = await self.session
+        async with session.create_client(service_name="glue", region_name=region) as client:
+            tasks = [client.get_job_runs(
+                JobName=job_name,
+                MaxResults=max_results
+            ) for job_name in job_names]
+            response = await asyncio.gather(*tasks)
+        return response

nimble_aws-0.1.0/nimble_aws/adapter/lambda_serverless.py

@@ -0,0 +1,26 @@
+import json
+
+from .config import env
+from .session import Session
+
+
+class Lambda(Session):
+    
+    async def invoke(self, function_name, payload, invocation_type="RequestResponse", region=env.region):
+        """
+        Invoke a Lambda function.
+        :param function_name: The name of the function.
+        :param payload: The payload to send to the function.
+        :param invocation_type: The invocation type, valid values are Event | RequestResponse | DryRun (default: RequestResponse).
+        :param region: The region of the function (default: us-east-1).
+        :return: The response payload from the Lambda API.
+        """
+        session = await self.session
+        async with session.create_client("lambda", region_name=region) as client:
+            response = await client.invoke(
+                FunctionName=function_name,
+                InvocationType=invocation_type,
+                Payload=json.dumps(payload).encode("utf-8")
+            )
+        return json.loads(response["Payload"].read().decode("utf-8")) if invocation_type == "RequestResponse" else response["Payload"].read()
+    

nimble_aws-0.1.0/nimble_aws/adapter/s3.py

@@ -0,0 +1,167 @@
+import asyncio
+from botocore.client import Config
+
+from .config import env
+from .session import Session
+
+
+class S3(Session):
+    
+    @staticmethod
+    def extract_filename_from_files_list(files_list):
+        return [f"{file['Name']}/{content['Key']}" for file in files_list for content in file["Contents"]]
+    
+    async def get_files(self, bucket, paths, decode=True, region=env.region):
+        """
+        Get a list of files from an S3 bucket.
+        :param bucket: The name of the bucket.
+        :param paths: The paths to the files.
+        :param decode: Whether to decode the files (default: True).
+        :param region: The region of the bucket (default: us-east-1).
+        :return: The files.
+        """
+        
+        session = await self.session
+        async with session.create_client(service_name="s3", region_name=region) as client:
+            tasks = [client.get_object(Bucket=bucket, Key=path) for path in paths]
+            results = await asyncio.gather(*tasks)
+            files = [await result["Body"].read() for result in results]
+        return [file.decode("utf-8") for file in files] if decode else files
+    
+    async def list_files(self, bucket, prefix_list, region=env.region):
+        """
+        List files in an S3 bucket.
+        :param bucket: The name of the bucket.
+        :param prefix_list: The prefixes to list.
+        :param region: The region of the bucket (default: us-east-1).
+        :return: The response from the S3 API.
+        """
+        
+        session = await self.session
+        async with session.create_client(service_name="s3", region_name=region) as client:
+            tasks = [client.list_objects_v2(Bucket=bucket, Prefix=prefix, Delimiter="/") for prefix in prefix_list]
+            results = await asyncio.gather(*tasks)
+        return results
+    
+    async def put_file(self, bucket, key, body, region=env.region):
+        """
+        Put a file into an S3 bucket.
+        :param bucket: The name of the bucket.
+        :param key: The key of the file.
+        :param body: The body of the file.
+        :param region: The region of the bucket (default: us-east-1).
+        :return: The response from the S3 API.
+        """
+        
+        session = await self.session
+        async with session.create_client(service_name="s3", region_name=region) as client:
+            response = await client.put_object(Bucket=bucket, Key=key, Body=body)
+        return response
+
+    async def put_files(self, bucket, objects, region=env.region):
+        """
+        Put files into an S3 bucket.
+        :param bucket: The name of the bucket.
+        :param objects: The objects to put.
+        :param region: The region of the bucket (default: us-east-1).
+        :return: The response from the S3 API.
+        """
+        
+        session = await self.session
+        async with session.create_client(service_name="s3", region_name=region) as client:
+            tasks = [client.put_object(Bucket=bucket, Key=object["key"], Body=object["body"]) for object in objects]
+            results = await asyncio.gather(*tasks)
+        return results
+    
+    async def put_files_with_content_type(self, bucket, objects, region=env.region):
+        """
+        Put files into an S3 bucket with content type.
+        :param bucket: The name of the bucket.
+        :param objects: The objects to put.
+        :param region: The region of the bucket (default: us-east-1).
+        :return: The response from the S3 API.
+        """
+        
+        session = await self.session
+        async with session.create_client(service_name="s3", region_name=region) as client:
+            tasks = [client.put_object(Bucket=bucket, Key=object["key"], Body=object["body"], ContentType=object["type"]) for object in objects]
+            results = await asyncio.gather(*tasks)
+        return results
+    
+    async def put_files_with_metadata(self, bucket, objects, region=env.region):
+        """
+        Put files into an S3 bucket with metadata.
+        :param bucket: The name of the bucket.
+        :param objects: The objects to put.
+        :param region: The region of the bucket (default: us-east-1).
+        :return: The response from the S3 API.
+        """
+        
+        session = await self.session
+        async with session.create_client(service_name="s3", region_name=region) as client:
+            tasks = [client.put_object(Bucket=bucket, Key=object["key"], Body=object["body"], Metadata=object["metadata"]) for object in objects]
+            results = await asyncio.gather(*tasks)
+        return results
+    
+    async def head_files(self, bucket, keys, region=env.region):
+        """
+        Get the metadata of files in an S3 bucket.
+        :param bucket: The name of the bucket.
+        :param keys: The keys of the files.
+        :param region: The region of the bucket (default: us-east-1).
+        :return: The response from the S3 API.
+        """
+        
+        session = await self.session
+        async with session.create_client(service_name="s3", region_name=region) as client:
+            tasks = [client.head_object(Bucket=bucket, Key=key) for key in keys]
+            results = await asyncio.gather(*tasks)
+        return results
+    
+    async def generate_pre_signed_url(self, bucket, item, expiration, region=env.region):
+        """
+        Generate a pre-signed URL for a file in an S3 bucket.
+        :param bucket: The name of the bucket.
+        :param item: The item to generate a URL for.
+        :param expiration: The expiration time of the URL.
+        :param region: The region of the bucket (default: us-east-1).
+        :return: The pre-signed URL.
+        """
+        
+        session = await self.session
+        async with session.create_client(service_name="s3", region_name=region, config=Config(signature_version="s3v4")) as client:
+            response = await client.generate_presigned_url(
+                ClientMethod="get_object", 
+                Params={
+                    "Bucket": bucket, 
+                    "Key": item["key"],
+                    "ReponseContentDisposition": f"attachment; filename={item['name']}"
+                }, 
+                ExpiresIn=expiration
+            )
+        return response
+    
+    async def generate_pre_signed_urls(self, bucket, data, expiration, region=env.region):
+        """
+        Generate pre-signed URLs for files in an S3 bucket.
+        :param bucket: The name of the bucket.
+        :param data: The data to generate URLs for.
+        :param expiration: The expiration time of the URLs.
+        :param region: The region of the bucket (default: us-east-1).
+        :return: The pre-signed URLs.
+        """
+        
+        session = await self.session
+        async with session.create_client(service_name="s3", region_name=region, config=Config(signature_version="s3v4")) as client:
+            tasks = [
+                client.generate_presigned_url(
+                    ClientMethod="get_object", 
+                    Params={
+                        "Bucket": bucket, 
+                        "Key": item["key"],
+                        "ReponseContentDisposition": f"attachment; filename={item['name']}"
+                    }, 
+                    ExpiresIn=expiration
+                ) for item in data]
+            results = await asyncio.gather(*tasks)
+        return results

nimble_aws-0.1.0/nimble_aws/adapter/secrets_manager.py

@@ -0,0 +1,20 @@
+import json
+
+from .config import env
+from .session import Session
+
+
+class SecretsManager(Session):
+
+    async def get_secret(self, secret_id, region=env.region):
+        """
+        Get a secret.
+        :param secret_id: The ID of the secret.
+        :param region: The region of the secret (default: us-east-1).
+        :return: The requested secret id value.
+        """
+        session = await self.session
+        async with session.create_client(service_name="secretsmanager", region_name=region) as client:
+            response = await client.get_secret_value(SecretId=secret_id)
+            secrets = json.loads(response["SecretString"])
+        return secrets

nimble_aws-0.1.0/nimble_aws/adapter/session.py

@@ -0,0 +1,22 @@
+from aiobotocore.session import get_session
+
+
+class Singleton(type):
+    _instances = {}
+
+    def __call__(cls, *args, **kwargs):
+        if cls not in cls._instances:
+            cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
+        return cls._instances[cls]
+
+
+class Session(metaclass=Singleton):
+    
+    def __init__(self):
+        self._session = None
+
+    @property
+    def session(self):
+        if self._session is None:
+            self._session = get_session()
+        return self._session

nimble_aws-0.1.0/nimble_aws/adapter/sfn.py

@@ -0,0 +1,38 @@
+import json
+import asyncio
+
+from .config import env
+from .utils import flatten
+from .session import Session
+
+
+class SFN(Session):
+    
+    async def run_sync_execution(self, state_machine_arn, payload, region=env.region):
+        """
+        Start an execution.
+        :param state_machine_arn: The ARN of the state machine.
+        :param input: The input to the execution.
+        :param region: The region of the state machine (default: us-east-1).
+        :return: The output from the Step Functions API.
+        """
+        session = await self.session
+        async with session.create_client(service_name="stepfunctions", region_name=region) as client:
+            response = await client.start_sync_execution(
+                stateMachineArn=state_machine_arn,
+                input=json.dumps(payload)
+            )
+        return json.loads(response.get("output") or response.get("cause"))
+    
+    async def run_sync_executions(self, data, region=env.region):
+        """
+        Start multiple executions.
+        :param data: The data to execute.
+        :param region: The region of the state machine (default: us-east-1).
+        :return: The output from the Step Functions API.
+        """
+        session = await self.session
+        async with session.create_client(service_name="stepfunctions", region_name=region) as client:
+            tasks = [client.start_sync_execution(stateMachineArn=item["arn"], input=json.dumps(item["input"])) for item in data]
+            responses = await asyncio.gather(*tasks)
+        return flatten([json.loads(response.get("output") or response.get("cause")) for response in responses])

nimble_aws-0.1.0/nimble_aws/adapter/sns.py

@@ -0,0 +1,35 @@
+import asyncio
+
+from .config import env
+from .session import Session
+
+
+class SNS(Session):
+    
+    async def publish_messages_to_topic(self, topic_arn, messages, region=env.region):
+        """
+        Publish messages to a topic.
+        :param topic_arn: The ARN of the topic.
+        :param messages: The messages to publish.
+        :param region: The region of the topic (default: us-east-1).
+        :return: The response from the SNS API.
+        """
+        session = await self.session
+        async with session.create_client(service_name="sns", region_name=region) as client:
+            tasks = [client.publish(TopicArn=topic_arn, Message=message) for message in messages]
+            responses = await asyncio.gather(*tasks)
+        return responses
+    
+    async def publish_messages_with_attributes_to_topic(self, topic_arn, messages, region=env.region):
+        """
+        Publish messages with attributes to a topic.
+        :param topic_arn: The ARN of the topic.
+        :param messages: The messages to publish.
+        :param region: The region of the topic (default: us-east-1).
+        :return: The response from the SNS API.
+        """
+        session = await self.session
+        async with session.create_client(service_name="sns", region_name=region) as client:
+            tasks = [client.publish(TopicArn=topic_arn, Message=message["message"], MessageAttributes=message["attributes"]) for message in messages]
+            responses = await asyncio.gather(*tasks)
+        return responses

nimble_aws-0.1.0/nimble_aws/adapter/sqs.py

@@ -0,0 +1,86 @@
+import json
+import asyncio
+from uuid import uuid4
+
+from .config import env
+from .session import Session
+from .utils import chunk_array
+
+
+class SQS(Session):
+    
+    @staticmethod
+    def get_messages(result):
+        return [json.loads(message["Body"]) for message in result.get("Messages", [])]
+    
+    async def publish_messages_to_queue(self, queue_url, messages, batch_size=10, region=env.region):
+        """
+        Publish messages to a queue.
+        :param queue_url: The URL of the queue.
+        :param messages: The messages to publish.
+        :param batch_size: The number of messages to publish in a batch (default: 10).
+        :param region: The region of the queue (default: us-east-1).
+        :return: The response from the SQS API.
+        """
+        chunks = chunk_array(messages, batch_size)
+        
+        session = await self.session
+        async with session.create_client(service_name="sqs", region_name=region) as client:
+            tasks = [
+                client.send_message_batch(
+                    QueueUrl=queue_url,
+                    Entries=[{"Id": str(uuid4()), "MessageBody": json.dumps(message)} for message in chunk]
+                ) for chunk in chunks]
+            responses = await asyncio.gather(*tasks)
+        return responses
+
+    async def read_ten_messages(self, queue_url, region=env.region, **kwargs):
+        """
+        Read ten messages from a queue.
+        :param queue_url: The URL of the queue.
+        :param region: The region of the queue (default: us-east-1).
+        :return: The messages from the SQS API.
+        """
+        session = await self.session
+        async with session.create_client(service_name="sqs", region_name=region) as client:
+            response = await client.receive_message(
+                QueueUrl=queue_url,
+                MaxNumberOfMessages=10,
+                **kwargs
+            )
+        return self.get_messages(response)
+    
+
+    async def read_messages(self, queue_url, num_messages=10, region=env.region, **kwargs):
+        """
+        Read messages from a queue.
+        :param queue_url: The URL of the queue.
+        :param num_messages: The number of messages to read (default: 10).
+        :param region: The region of the queue (default: us-east-1).
+        :return: The messages from the SQS API.
+        """
+        messages_read = 0
+        all_messages = list()  
+        messages = await self.read_ten_messages(queue_url, region, **kwargs)
+        all_messages.extend(messages)
+        messages_read += len(messages)
+        while messages and messages_read < num_messages:
+            messages = await self.read_ten_messages(queue_url, region, **kwargs)
+            all_messages.extend(messages)
+            messages_read += len(messages)
+        return all_messages
+    
+    async def read_all_messages(self, queue_url, region=env.region, **kwargs):
+        """
+        Read all messages from a queue.
+        :param queue_url: The URL of the queue.
+        :param region: The region of the queue (default: us-east-1).
+        :return: The messages from the SQS API.
+        """
+        all_messages = list()  
+        messages = await self.read_ten_messages(queue_url, region, **kwargs)
+        all_messages.extend(messages)
+        while messages:
+            messages = await self.read_ten_messages(queue_url, region, **kwargs)
+            all_messages.extend(messages)
+        return all_messages

nimble_aws-0.1.0/nimble_aws/adapter/utils.py

@@ -0,0 +1,9 @@
+
+
+
+def flatten(array):
+    return [item for sublist in array for item in sublist]
+
+
+def chunk_array(array, chunk_size):
+    return [array[i:i + chunk_size] for i in range(0, len(array), chunk_size)]

nimble_aws-0.1.0/nimble_aws/middleware/api_gateway.py

@@ -0,0 +1,101 @@
+import json
+from decimal import Decimal
+from datetime import datetime
+
+
+class Encoder(json.JSONEncoder):
+    
+    def defaul(self, obj):
+        if isinstance(obj, Decimal):
+            if obj % 1 == 0:
+                return int(obj)
+            return float(obj)
+        elif isinstance(obj, datetime):
+            return obj.strftime("%Y-%m-%d")
+        return str(obj)
+
+
+class API:
+    
+    def __init__(self, event, **args):
+        self.event = event
+        self.extra_params = args
+        
+    @staticmethod
+    def get_default(data, field, default):
+        return data[field] if data.get(field) else default
+    
+    @property
+    def body(self):
+        raw_body = self.get_default(self.event, field="body", default={})
+        return json.loads(raw_body)
+    
+    @property
+    def headers(self):
+        raw_headers = self.get_default(self.event, field="headers", default={})
+        return {k.lower(): v for k, v in raw_headers.items()}
+    
+    @property
+    def path_parameters(self):
+        return self.get_default(self.event, field="pathParameters", default={})
+    
+    @property
+    def path(self):
+        return self.event["requestContext"]["resourcePath"] if self.event["requestContext"].get("resourcePath") else self.event["requestContext"]["routeKey"].split(" ")[-1]
+    
+    @property
+    def query_string_parameters(self):
+        return self.get_default(self.event, field="queryStringParameters", default={})
+    
+    @property
+    def request(self):
+        return {
+            "headers": self.headers,
+            "path": self.path,
+            "path_parameters": self.path_parameters,
+            "query_string_parameters": self.query_string_parameters,
+            "body": self.body   
+        }
+    
+    @property
+    def response_headers(self):
+        cors_headers = {}
+        origin = self.get_default(self.headers, field="origin", default="")
+        allowed = "*" in self.extra_params["cors-allowed-origin"]
+        if origin is self.extra_params["cors-allowed-origin"] or allowed:
+            cors_headers = {
+                "Access-Control-Allow-Origin": origin,
+                "Access-Control-Allow-Credentials": "true",
+                "Access-Control-Allow-Methods": self.extra_params["cors-allowed-methods"],
+                "Access-Control-Allow-Headers": self.extra_params["cors-allowed-headers"]
+            }
+        return {
+            **cors_headers,
+            "X-XSS-Protection": "1; mode=block",
+            "X-Frame-Options": "DENY",
+            "X-Content-Type-Options": "nosniff",
+            "Referrer-Policy": "strict-origin-when-cross-origin",
+            "Strict-Transport-Security": "max-age=31536000; includeSubDomains"
+        }
+    
+    @property
+    def error_response(self, exception):
+        if exception.__class__.__name__ != "":
+            exception.args = ({"pt": "Erro", "en": "Error"}, 500)
+        return {
+            "statusCode": exception.args[1],
+            "headers": self.response_headers,
+            "body": {
+                "error": {
+                    "type": type(exception).__name__,
+                    "description": exception.args[0]
+                }
+            }
+        }
+    
+    def success_response(self, data):
+        return {
+            "statusCode": 200,
+            "headers": self.response_headers,
+            "body": json.dumps(data, cls=Encoder, ensure_ascii=False)
+        }

nimble_aws-0.1.0/pyproject.toml

@@ -0,0 +1,18 @@
+[tool.poetry]
+name = "nimble-aws"
+version = "0.1.0"
+description = ""
+authors = ["Lucas Tiense Blazzi <lucast.blazzi@gmail.com>"]
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^3.11"
+pydantic = "^2.4.2"
+pydantic-settings = "^2.0.3"
+aiobotocore = "2.13.1"
+boto3 = "^1.17.47"
+
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"