my-aws-helpers 1.6.0__tar.gz → 2.0.0__tar.gz

{my_aws_helpers-1.6.0 → my_aws_helpers-2.0.0}/PKG-INFO

@@ -1,13 +1,16 @@
 Metadata-Version: 2.1
 Name: my_aws_helpers
-Version: 1.6.0
+Version: 2.0.0
 Summary: AWS Helpers
 Home-page: https://github.com/JarrodMccarthy/aws_helpers.git
 Author: Jarrod McCarthy
+License: UNKNOWN
 Platform: any
 Classifier: License :: Other/Proprietary License
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
-Requires-Dist: boto3==1.34.36
+
+UNKNOWN
+

my_aws_helpers-2.0.0/my_aws_helpers/api.py

@@ -0,0 +1,54 @@
+from typing import Optional, Dict, Any
+import json
+from my_aws_helpers.errors import *
+
+
+class API:
+    def response(code: int, body: Optional[str] = None):
+        return {
+            "statusCode": code,
+            "headers": {"Access-Control-Allow-Origin": "*"},
+            "body": body,
+        }
+
+    def get_optional_query_string_param(event: dict, param: str) -> Optional[Any]:
+        query_string_params = event.get("queryStringParameters")
+        if query_string_params is None:
+            return None
+        else:
+            return query_string_params.get(param)
+
+    def get_optional_body_param(event: dict, param: str):
+        body = event.get("body")
+        if body is None:
+            return None
+        else:
+            body = json.loads(body)
+        param_value = body.get(param)
+        return param_value
+
+    def parse_payload(event: Dict[str, Any]):
+        payload = {}
+        if event.get("queryStringParameters"):
+            payload["queryStringParameters"] = event["queryStringParameters"]
+        if event.get("pathParameters"):
+            payload["pathParameters"] = event["pathParameters"]
+        if event.get("body"):
+            payload["body"] = json.loads(event["body"])
+        return payload
+
+    def handle_error_response(func):
+        def wrapper(event, context):
+            try:
+                response = func(event, context)
+                return API.response(code=200, body=json.dumps(response))
+            except ClientError as e:
+                return API.response(code=400, body=json.dumps({"Error": f"{e}"}))
+            except NotFoundError as e:
+                return API.response(code=404, body=json.dumps({"Error": f"{e}"}))
+            except ServerError as e:
+                return API.response(code=500, body=json.dumps({"Error": f"{e}"}))
+            except Exception as e:
+                return API.response(code=500, body=json.dumps({"Error": f"{e}"}))
+
+        return wrapper

my_aws_helpers-2.0.0/my_aws_helpers/auth.py

@@ -0,0 +1,16 @@
+from my_aws_helpers.logging import select_powertools_logger
+
+
+logger = select_powertools_logger("aws-helpers-s3")
+
+
+class Auth:
+
+    @staticmethod
+    def get_bearer_from_lambda_event(event: dict) -> str:
+        try:
+            bearer_token = event["headers"]["Authorization"]
+            return str(bearer_token).split("Bearer")[-1]
+        except Exception as e:
+            logger.exception(f"Failed to get bearer from lambda event due to {e}")
+        return None

{my_aws_helpers-1.6.0 → my_aws_helpers-2.0.0}/my_aws_helpers/cognito.py

@@ -51,7 +51,7 @@
 #                         'Name': 'Full Name',
 #                         'Value': user.fullname,
 #                         'Name': 'name',
-#                         'Value': user.fullname,                        
+#                         'Value': user.fullname,
 #                         'Name': 'nickname',
 #                         'Value': user.nickname,
 #                         'Name': 'email',
@@ -75,7 +75,7 @@
 #     def _init_auth(self, cognito_username: str, user: User):
 #         """Initiate Auth (SRP) -> Returns Challenge"""
 #         try:
-#             response = self.client.initiate_auth(            
+#             response = self.client.initiate_auth(
 #                 AuthFlow='USER_PASSWORD_AUTH', #'USER_SRP_AUTH'|'REFRESH_TOKEN_AUTH'|'REFRESH_TOKEN'|'CUSTOM_AUTH'|'ADMIN_NO_SRP_AUTH'| 'USER_PASSWORD_AUTH',
 #                 AuthParameters={
 #                     'USERNAME': user.email,
@@ -89,7 +89,7 @@
 #         except Exception as e:
 #             raise Exception(f"Error {e}: Issue during initialising auth for user {cognito_username}")
 
-#     def _respond_to_auth_challenge(self, init_auth_response, user: User, cognito_username: str): 
+#     def _respond_to_auth_challenge(self, init_auth_response, user: User, cognito_username: str):
 #         """Respond to Auth Challenge -> Cognito Tokens"""
 #         try:
 #             cognito_username = init_auth_response["ChallengeParameters"].get('USER_ID_FOR_SRP') #needs testing
@@ -110,13 +110,13 @@
 #             return response
 #         except Exception as e:
 #              raise Exception(f"Error {e}: Issue responding to auth challenge for user {user.email}")
-        
+
 #     # def get_token(self, user: User, cognito_username: str):
 #     #     init_auth_response = self._init_auth(cognito_username, user)
 #     #     response = self._respond_to_auth_challenge(init_auth_response, user, cognito_username)
 #     #     return response
 
-#     # def sign_up(self, user: User): 
+#     # def sign_up(self, user: User):
 #     #     response = self.create_user(user)
 #     #     cognito_username = response['User'].get('Username')
 #     #     get_token_response = self.get_token(user, cognito_username)
@@ -141,4 +141,4 @@
 #     #     JWT = tokens['id_token']
 #     #     response = requests.request("GET", self.cognito_known_tokens_url, headers={}, data={})
 #     #     public = json.loads(response.text) #loads a json str into dict
-#     #     return jwt.decode(JWT, public) #decode jwt 
+#     #     return jwt.decode(JWT, public) #decode jwt

my_aws_helpers-2.0.0/my_aws_helpers/dynamo.py

@@ -0,0 +1,202 @@
+from typing import List, Any, Optional
+from datetime import datetime, date
+import boto3
+from abc import ABC, abstractmethod
+from decimal import Decimal, Context 
+
+from my_aws_helpers.logging import select_powertools_logger
+
+logger = select_powertools_logger("aws-helpers-dynamo")
+
+class MetaData:
+    """
+    This class is a convenience class,
+    each of its attributes will be attached to objects that inherit from `BaseTableObject`
+    """
+
+    created_by: Optional[str]
+    created_on: Optional[datetime]
+    updated_by: Optional[str]
+    updated_on: Optional[datetime]
+
+    def set_timestamp(self, ts: Any) -> datetime:
+        """Be absolutely sure timestamps are datetimes"""
+        if isinstance(ts, datetime):
+            return ts
+        else:
+            return datetime.now()
+
+    def __init__(self, **kwargs) -> None:
+        self.created_by = (
+            kwargs["created_by"] if kwargs.get("created_by") else self._get_user()
+        )
+        self.updated_by = (
+            kwargs["updated_by"] if kwargs.get("updated_by") else self._get_user()
+        )
+        self.created_on = self.set_timestamp(ts=kwargs.get("created_on"))
+        self.updated_on = self.set_timestamp(ts=kwargs.get("updated_on"))
+
+    def _get_user(self):
+        """This should probably do some clever thing to get the actual user details from the token or something"""
+        return ""
+
+
+class BaseTableObject(MetaData):
+    """
+    An Abstract class that helps ensure your objects
+    conform to the AssetTable schema and
+    implement serialisation/deserialisation for Dynamo
+    """
+
+    pk: str
+    sk: str
+
+    def _get_pk(self):
+        pass
+
+    def _get_sk(self):
+        pass
+
+    @abstractclassmethod
+    def _from_dynamo_representation():
+        """
+        Deserialises this object from Dynamo Representation
+        """
+        pass
+
+    @abstractmethod
+    def _to_dynamo_representation():
+        """
+        Serialises this object to Dynamo Representation
+        """
+        pass
+
+    def _optional_get(self, kwargs: dict, key: str, default: Any):
+        return kwargs.get(key) if kwargs.get(key) else default
+
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.pk = self._optional_get(kwargs=kwargs, key="pk", default=self._get_pk())
+        self.sk = self._optional_get(kwargs=kwargs, key="sk", default=self._get_sk())
+
+
+class DynamoSerialiser:
+
+    @staticmethod
+    def _serialise(obj: Any):
+        if isinstance(obj, datetime) or isinstance(obj, date):
+            return obj.isoformat()
+        if isinstance(obj, float):
+            ctx = Context(prec = 38)
+            return ctx.create_decimal_from_float(obj)
+        return obj
+    
+    @staticmethod
+    def object_serialiser(obj: Any):
+        if isinstance(obj, list):
+            return [DynamoSerialiser.object_serialiser(obj=obj) for obj in obj]
+        if isinstance(obj, dict):
+            return {k: DynamoSerialiser.object_serialiser(v) for k, v in obj.items()}
+        return DynamoSerialiser._serialise(obj=obj)
+
+class Dynamo:
+    table: boto3.resource
+
+    def __init__(self, table_name: str) -> None:
+        ddb = boto3.resource("dynamodb")
+        self.table = ddb.Table(table_name)
+
+    def put_item(self, item: dict):
+        return self.table.put_item(Item=item)
+
+    def get_item(self, item: dict):
+        return self.table.get_item(Item=item)
+
+    def delete_item(self, item: dict):
+        return self.table.delete_item(Item=item)
+
+    def batch_put(self, items: List[dict]) -> None:
+        with self.table.batch_writer() as batch:
+            for item in items:
+                batch.put_item(Item=item)
+        return
+
+    def batch_delete(self, items: List[dict]) -> None:
+        with self.table.batch_writer() as batch:
+            for item in items:
+                batch.delete_item(Key=item)
+        return
+
+    def _deep_scan(self):
+        response = self.table.scan()
+        items: List = response["Items"]
+        while response.get("LastEvaluatedKey") is not None:
+            response = self.table.scan(ExclusiveStartKey = response["LastEvaluatedKey"])
+            if response.get("Items") is not None:
+                items.extend(response["Items"])
+            if response.get("LastEvaluatedKey") is None:
+                break
+        return items
+
+    def delete_table_items(self, partition_key_name: str = "pk", sort_key_name: str = "sk") -> bool:
+        try:
+            items = self._deep_scan()
+            delete_repr_items = [
+                {
+                    partition_key_name: item[partition_key_name],
+                    sort_key_name: item[sort_key_name],
+                }
+                for item in items
+            ]
+            self.batch_delete(items = delete_repr_items)
+            return True
+        except Exception as e:
+            logger.exception(f'Failed to delete table items due to {e}')
+            return False
+
+    def to_dynamo_representation(obj: dict):
+        """
+        Attempts to put common datatype transformations in one spot
+        """
+        new_obj = dict()
+        for key, value in obj.items():
+            new_obj[key] = _datatype_map(value=value)
+        return new_obj
+
+
+def _datatype_map(value: Any):
+    if isinstance(value, float):
+        return Decimal(str(value))
+    if (isinstance(value, date)) or (isinstance(value, datetime)):
+        return value.isoformat()
+    if isinstance(value, list):
+        return [_datatype_map(value=item) for item in value]
+    if isinstance(value, dict):
+        new_obj = dict()
+        for k, v in value.items():
+            new_obj[k] = _datatype_map(value=v)
+        return new_obj
+    return value
+
+class BaseQueries(ABC):
+    table_name: str
+
+    def __init__(self, table_name: str, client: Optional[Dynamo] = None) -> None:
+        self.table_name = table_name
+        self.client = self._get_client() if client is None else client
+
+    def _get_client(self):
+        return Dynamo(table_name=self.table_name)
+    
+    def _iterative_query(self, query_kwargs: dict) -> List[dict]:
+        results = list()
+        last_evaluated_key = "not none"
+        exclusive_start_key = None
+        while last_evaluated_key is not None:
+            if exclusive_start_key is not None:
+                query_kwargs["ExclusiveStartKey"] = exclusive_start_key
+            result = self.client.table.query(**query_kwargs)
+            results += result["Items"]
+            last_evaluated_key = result.get("LastEvaluatedKey")
+            exclusive_start_key = last_evaluated_key
+        return results

my_aws_helpers-2.0.0/my_aws_helpers/errors.py

@@ -0,0 +1,14 @@
+class AlreadyExists(Exception):
+    pass
+
+
+class ClientError(Exception):
+    pass
+
+
+class NotFoundError(Exception):
+    pass
+
+
+class ServerError(Exception):
+    pass

my_aws_helpers-2.0.0/my_aws_helpers/logging.py

@@ -0,0 +1,20 @@
+import logging
+import os
+
+
+def select_powertools_logger(service_name: str) -> logging.Logger:
+    """
+    Returns the powertools logger if it can be found,
+    Returns a Logger with name = service_name if powertools logger is not found
+    """
+    existing_loggers = [name for name in logging.root.manager.loggerDict]
+    powertools_service_name = os.environ.get("POWERTOOLS_SERVICE_NAME")
+    if powertools_service_name is not None:
+        logger = (
+            logging.getLogger(powertools_service_name)
+            if powertools_service_name in existing_loggers
+            else None
+        )
+        if logger:
+            return logger
+    return logging.getLogger(service_name)

my_aws_helpers-2.0.0/my_aws_helpers/s3.py

@@ -0,0 +1,207 @@
+import boto3
+import io
+import json
+from typing import Optional, Any, Dict
+from copy import copy
+import os
+import gzip
+from enum import Enum
+from my_aws_helpers.logging import select_powertools_logger
+
+
+logger = select_powertools_logger("aws-helpers-s3")
+
+
+class ContentType(str, Enum):
+    plain_text = "text/plain"
+    xml_content = "text/xml"
+    json_content = "application/json"
+    pdf_content = "application/pdf"
+
+
+class ContentEncoding(str, Enum):
+    gzip = "gzip"
+
+
+class S3Location:
+    bucket: str
+    file_name: str
+    location: str
+
+    @classmethod
+    def from_location(cls, location: str):
+        bucket, file_name = location.split("/")[0], "/".join(location.split("/")[1:])
+        return cls(bucket=bucket, file_name=file_name)
+
+    def __init__(self, bucket: str, file_name: str) -> None:
+        self.bucket = bucket
+        self.file_name = file_name
+        self.location = f"{self.bucket}/{self.file_name}"
+
+    def serialise(self):
+        return copy(vars(self))
+
+
+class S3:
+    client: boto3.client
+
+    def __init__(self, client: Optional[boto3.client] = None) -> None:
+        self.client = client if client else self._get_client()
+
+    def _get_client(self) -> boto3.client:
+        region_name = os.environ["AWS_DEFAULT_REGION"]
+        s3_client = boto3.client("s3", region_name=region_name)
+        endpoint_url = s3_client.meta.endpoint_url
+        s3_client = boto3.client(
+            "s3", region_name=region_name, endpoint_url=endpoint_url
+        )
+        return s3_client
+
+    def _streaming_body_to_dict(self, payload):
+        file_like_obj = io.BytesIO(payload.read())
+        response = json.loads(file_like_obj.getvalue())
+        return response
+
+    def put_json_object(self, bucket_name: str, file_name: str, object: dict):
+        return self.client.put_object(
+            Body=json.dumps(object), Bucket=bucket_name, Key=file_name
+        )
+
+    def get_object(self, bucket_name: str, file_name: str):
+        response = self.client.get_object(Bucket=bucket_name, Key=file_name)
+        return self._streaming_body_to_dict(response["Body"])
+
+    def get_presigned_url(
+        self, bucket_name: str, file_name: str, expires_in: int = 3600
+    ):
+        return self.client.generate_presigned_url(
+            "get_object",
+            Params={
+                "Bucket": bucket_name,
+                "Key": file_name,
+            },
+            ExpiresIn=expires_in,
+        )
+
+    def get_s3_location_from_bucket_file(
+        bucket_name: str, file_name: str
+    ) -> S3Location:
+        return S3Location(bucket=bucket_name, file_name=file_name)
+
+    def get_bucket_file_from_s3_location(s3_location: S3Location) -> S3Location:
+        return S3Location.from_location(location=s3_location)
+
+    def save_document_content(
+        self,
+        file_contents: bytes,
+        s3_location: S3Location,
+        content_encoding: str = "",
+        content_type: str = "application/pdf",
+        compress: bool = True,
+    ) -> Optional[S3Location]:
+        """
+        saves document content to bucket, in file_name
+        Options for content_type:
+            "application/pdf"
+            "text/plain"
+            "application/json"
+            probably more
+        Options for content_encoding:
+            "": default encoding
+            "gzip": compressed contents
+        """
+        try:
+            if compress or s3_location.file_name.endswith(".gz"):
+                file_contents = gzip.compress(file_contents)
+                content_encoding = ContentEncoding.gzip.value
+            obj = self.client.Object(s3_location.bucket, s3_location.file_name)
+            obj.put(
+                Body=file_contents,
+                ContentType=content_type,
+                ContentEncoding=content_encoding,
+            )
+            return s3_location
+        except Exception as e:
+            logger.exception(e)
+            return None
+
+    def read_binary_from_s3(self, s3_location: S3Location) -> Optional[bytes]:
+        try:
+            obj = self.client.Object(s3_location.bucket, s3_location.file_name)
+            d_bytes = io.BytesIO()
+            obj.download_fileobj(d_bytes)
+            d_bytes.seek(0)
+            if obj.content_encoding == ContentEncoding.gzip.value:
+                try:
+                    with gzip.GzipFile(fileobj=d_bytes) as gz_file:
+                        return gz_file.read()
+                except gzip.BadGzipFile:
+                    d_bytes.seek(0)
+            return d_bytes.read()
+        except Exception as e:
+            logger.exception(f"Failed to read binary from s3 due to {e}")
+            return None
+
+    def save_text_to_s3(self, text: str, s3_location: S3Location):
+        try:
+            file_contents = bytes(text.encode("UTF-8"))
+            return self.save_document_content(
+                file_contents=file_contents,
+                s3_location=s3_location,
+                content_type=ContentType.plain_text.value,
+                compress=True,
+                content_encoding=ContentEncoding.gzip.value,
+            )
+        except Exception as e:
+            logger.exception(f"Failed to save text to s3 due to {e}")
+            return None
+
+    def save_xml_to_s3(self, xml_text: bytes, s3_location: S3Location):
+        """
+        xml_text tends to come from:
+            root = lxml.etree.ElementTree().get_root()
+            xml_text = ET.tostring(root, encoding='utf-8')
+        """
+        try:
+            return self.save_document_content(
+                file_contents=xml_text,
+                s3_location=s3_location,
+                content_type=ContentType.xml_content.value,
+                compress=True,
+                content_encoding=ContentEncoding.gzip.value,
+            )
+        except Exception as e:
+            logger.exception(f"Failed to save xml text to s3 due to {e}")
+            return None
+
+    def save_xml_to_s3(self, pdf_content: bytes, s3_location: S3Location):
+        """
+        pdf_content tends to come from:
+            PyMuPdf.Document().write()
+        """
+        try:
+            return self.save_document_content(
+                file_contents=pdf_content,
+                s3_location=s3_location,
+                content_type=ContentType.pdf_content.value,
+                compress=True,
+                content_encoding=ContentEncoding.gzip.value,
+            )
+        except Exception as e:
+            logger.exception(f"Failed to save pdf to s3 due to {e}")
+            return None
+
+    def save_dict_to_s3(self, content: Dict[str, Any], s3_location: S3Location):
+        """ """
+        try:
+            file_contents = bytes(json.dumps(content).encode("UTF-8"))
+            return self.save_document_content(
+                file_contents=file_contents,
+                s3_location=s3_location,
+                content_type=ContentType.json_content.value,
+                compress=True,
+                content_encoding=ContentEncoding.gzip.value,
+            )
+        except Exception as e:
+            logger.exception(f"Failed to save dict to s3 due to {e}")
+            return None

my_aws_helpers-2.0.0/my_aws_helpers/sfn.py

@@ -0,0 +1,44 @@
+import boto3
+from typing import Optional
+import json
+from uuid import uuid4
+from my_aws_helpers.api import API
+from my_aws_helpers.errors import *
+
+
+class SFN:
+    client: boto3.client
+
+    def __init__(self, client: Optional[boto3.client] = None) -> None:
+        self.client = client if client else boto3.client("stepfunctions")
+
+    def start_execution(
+        self,
+        sfn_arn: str,
+        event: Optional[dict] = None,
+        name: Optional[str] = uuid4().hex,
+    ):
+        input_event = json.dumps(event) if event else event
+        return self.client.start_execution(
+            stateMachineArn=sfn_arn,
+            name=name,
+            input=input_event,
+        )
+
+    def handle_error_response(func):
+        def wrapper(event, context):
+            try:
+                response = func(event, context)
+                return API.response(code=200, body=json.dumps(response))
+            except AlreadyExists as e:
+                return API.response(code=201, body=json.dumps({"Success": f"{e}"}))
+            except ClientError as e:
+                return API.response(code=400, body=json.dumps({"Error": f"{e}"}))
+            except NotFoundError as e:
+                return API.response(code=404, body=json.dumps({"Error": f"{e}"}))
+            except ServerError as e:
+                return API.response(code=500, body=json.dumps({"Error": f"{e}"}))
+            except Exception as e:
+                return API.response(code=500, body=json.dumps({"Error": f"{e}"}))
+
+        return wrapper

{my_aws_helpers-1.6.0 → my_aws_helpers-2.0.0}/my_aws_helpers.egg-info/PKG-INFO

@@ -1,13 +1,16 @@
 Metadata-Version: 2.1
-Name: my_aws_helpers
-Version: 1.6.0
+Name: my-aws-helpers
+Version: 2.0.0
 Summary: AWS Helpers
 Home-page: https://github.com/JarrodMccarthy/aws_helpers.git
 Author: Jarrod McCarthy
+License: UNKNOWN
 Platform: any
 Classifier: License :: Other/Proprietary License
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
-Requires-Dist: boto3==1.34.36
+
+UNKNOWN
+

{my_aws_helpers-1.6.0 → my_aws_helpers-2.0.0}/my_aws_helpers.egg-info/SOURCES.txt

@@ -2,9 +2,11 @@ README.md
 setup.cfg
 setup.py
 my_aws_helpers/api.py
+my_aws_helpers/auth.py
 my_aws_helpers/cognito.py
 my_aws_helpers/dynamo.py
 my_aws_helpers/errors.py
+my_aws_helpers/logging.py
 my_aws_helpers/s3.py
 my_aws_helpers/sfn.py
 my_aws_helpers.egg-info/PKG-INFO

{my_aws_helpers-1.6.0 → my_aws_helpers-2.0.0}/setup.py

@@ -3,7 +3,7 @@ from setuptools import find_namespace_packages, setup
 
 base_path = os.path.abspath(os.path.dirname(__file__))
 
-version = "1.6.0"
+version = "2.0.0"
 
 setup(
     name="my_aws_helpers",

my_aws_helpers-1.6.0/my_aws_helpers/api.py

@@ -1,65 +0,0 @@
-from typing import Optional, Dict, Any
-import json
-from my_aws_helpers.errors import *
-
-class API:
-    def response(code: int, body: Optional[str] = None):
-        return {
-            "statusCode": code, 
-            "headers": {"Access-Control-Allow-Origin": "*"},
-            "body": body,
-        }
-
-    def get_optional_query_string_param(event: dict, param: str) -> Optional[Any]: 
-        query_string_params = event.get("queryStringParameters")
-        if query_string_params is None:
-            return None
-        else:
-            return query_string_params.get(param)
-            
-
-    def get_optional_body_param(event: dict, param: str): 
-        body = event.get("body")
-        if body is None:
-            return None
-        else:
-            body = json.loads(body)
-        param_value = body.get(param)
-        return param_value
-
-    def parse_payload(event: Dict[str, Any]):
-        payload = {}
-        if event.get("queryStringParameters"): payload["queryStringParameters"] = event["queryStringParameters"]
-        if event.get("pathParameters"): payload["pathParameters"] = event["pathParameters"]
-        if event.get("body"): payload["body"] = json.loads(event["body"])
-        return payload
-    
-    def handle_error_response(func):
-        def wrapper(event, context):
-            try:
-                response = func(event, context)        
-                return API.response(
-                    code = 200, 
-                    body = json.dumps(response) 
-                )
-            except ClientError as e:
-                return API.response(
-                    code = 400, 
-                    body = json.dumps({"Error": f"{e}"}) 
-                )
-            except NotFoundError as e:
-                return API.response(
-                    code = 404, 
-                    body = json.dumps({"Error": f"{e}"}) 
-                )
-            except ServerError as e:
-                return API.response(
-                    code = 500, 
-                    body = json.dumps({"Error": f"{e}"}) 
-                )
-            except Exception as e:
-                return API.response(
-                    code = 500, 
-                    body = json.dumps({"Error": f"{e}"}) 
-                )
-        return wrapper

my_aws_helpers-1.6.0/my_aws_helpers/dynamo.py

@@ -1,125 +0,0 @@
-from typing import List, Any, Optional
-from datetime import datetime, date
-import boto3
-from abc import ABC, abstractclassmethod, abstractmethod
-from decimal import Decimal
-
-class MetaData:
-    """
-    This class is a convenience class, 
-    each of its attributes will be attached to objects that inherit from `BaseTableObject`
-    """
-    created_by: Optional[str]
-    created_on: Optional[datetime]
-    updated_by: Optional[str]
-    updated_on: Optional[datetime]
-
-    def set_timestamp(self, ts: Any) -> datetime:
-        """Be absolutely sure timestamps are datetimes"""
-        if isinstance(ts, datetime):
-            return ts
-        else:
-            return datetime.now()
-
-    def __init__(self, **kwargs) -> None:
-        self.created_by = kwargs["created_by"] if kwargs.get("created_by") else self._get_user()
-        self.updated_by = kwargs["updated_by"] if kwargs.get("updated_by") else self._get_user()
-        self.created_on = self.set_timestamp(ts=kwargs.get("created_on"))
-        self.updated_on = self.set_timestamp(ts=kwargs.get("updated_on"))
-
-    def _get_user(self):
-        """This should probably do some clever thing to get the actual user details from the token or something"""
-        return ""
-
-
-class BaseTableObject(MetaData):
-    """
-    An Abstract class that helps ensure your objects
-    conform to the AssetTable schema and
-    implement serialisation/deserialisation for Dynamo
-    """
-    pk: str
-    sk: str
-
-    def _get_pk(self):
-        pass
-
-    def _get_sk(self):
-        pass
-
-    @abstractclassmethod
-    def _from_dynamo_representation():
-        """
-        Deserialises this object from Dynamo Representation
-        """
-        pass
-
-    @abstractmethod
-    def _to_dynamo_representation():
-        """
-        Serialises this object to Dynamo Representation
-        """        
-        pass
-
-    def _optional_get(self, kwargs: dict, key: str, default: Any):
-        return kwargs.get(key) if kwargs.get(key) else default
-    
-    def __init__(self, **kwargs) -> None:
-        super().__init__(**kwargs)
-        self.pk = self._optional_get(kwargs=kwargs, key='pk', default=self._get_pk())
-        self.sk = self._optional_get(kwargs=kwargs, key='sk', default=self._get_sk())
-
-class BaseQueries(ABC):
-    table_name: str
-
-    def __init__(self, table_name: str) -> None:
-        self.table_name = table_name
-
-class Dynamo:
-    def __init__(self, table_name: str) -> None:
-        ddb = boto3.resource('dynamodb')
-        self.table = ddb.Table(table_name)
-    
-    def put_item(self, item: dict):
-        return self.table.put_item(Item=item)
-    
-    def get_item(self, item: dict):
-        return self.table.get_item(Item=item)
-    
-    def delete_item(self, item: dict):
-        return self.table.delete_item(Item=item)
-    
-    def batch_put(self, items: List[dict]) -> None:
-        with self.table.batch_writer() as batch:
-            for item in items:
-                batch.put_item(Item=item)
-        return 
-    
-    def batch_delete(self, items: List[dict]) -> None:
-        with self.table.batch_writer() as batch:
-            for item in items:
-                batch.delete_item(Key=item)
-        return
-
-    def to_dynamo_representation(obj: dict):
-        """
-        Attempts to put common datatype transformations in one spot
-        """
-        new_obj = dict()
-        for key, value in obj.items():
-            new_obj[key] = _datatype_map(value=value)
-        return new_obj
-    
-def _datatype_map(value: Any):
-    if (isinstance(value, float)):
-        return Decimal(str(value))
-    if (isinstance(value, date)) or (isinstance(value, datetime)):
-        return value.isoformat()
-    if (isinstance(value, list)):
-        return [_datatype_map(value = item) for item in value]
-    if (isinstance(value, dict)):
-        new_obj = dict()
-        for k, v in value.items():
-            new_obj[k] = _datatype_map(value=v)
-        return new_obj
-    return value

my_aws_helpers-1.6.0/my_aws_helpers/errors.py

@@ -1,8 +0,0 @@
-class AlreadyExists(Exception): pass
-
-class ClientError(Exception): pass
-
-class NotFoundError(Exception): pass
-
-class ServerError(Exception): pass
-

my_aws_helpers-1.6.0/my_aws_helpers/s3.py

@@ -1,116 +0,0 @@
-import boto3
-import io
-import json 
-from typing import Tuple, Optional
-from copy import copy
-import os 
-import gzip
-
-
-
-class S3Location:
-    bucket: str
-    file_name: str
-    location: str
-
-    @classmethod
-    def from_location(cls, location: str):
-        bucket, file_name = location.split('/')[0], '/'.join(location.split('/')[1:])
-        return cls(bucket = bucket, file_name = file_name)
-    
-    def __init__(self, bucket: str, file_name: str) -> None:
-        self.bucket = bucket
-        self.file_name = file_name
-        self.location = f"{self.bucket}/{self.file_name}"
-
-    def serialise(self):
-        return copy(vars(self))
-        
-
-class S3:
-    client: Optional[boto3.client]
-
-    def __init__(self, client: Optional[boto3.client]) -> None:
-        self.client = client if client else self._get_client()
-
-    def _get_client(self) -> boto3.client:
-        region_name = os.environ["AWS_DEFAULT_REGION"]
-        s3_client = boto3.client("s3", region_name=region_name)
-        endpoint_url = s3_client.meta.endpoint_url
-        s3_client = boto3.client("s3", region_name=region_name, endpoint_url=endpoint_url)
-        return s3_client
-
-    def _streaming_body_to_dict(self, payload):
-        file_like_obj = io.BytesIO(payload.read())
-        response = json.loads(file_like_obj.getvalue())
-        return response
-    
-    def put_json_object(self, bucket_name: str, file_name: str, object: dict):
-        return self.client.put_object(
-            Body = json.dumps(object),
-            Bucket = bucket_name,
-            Key = file_name
-        )
-    
-    def get_object(self, bucket_name: str, file_name: str):
-        response = self.client.get_object(
-            Bucket = bucket_name,
-            Key = file_name            
-        )
-        return self._streaming_body_to_dict(response["Body"])
-    
-    def get_presigned_url(self, bucket_name: str, file_name: str, expires_in: int = 3600):
-        return self.client.generate_presigned_url(
-            'get_object',
-            Params = {
-                "Bucket": bucket_name,
-                "Key": file_name,
-            },
-            ExpiresIn = expires_in
-        )
-    
-    def get_s3_location_from_bucket_file(bucket_name: str, file_name: str) -> S3Location:
-        return S3Location(bucket=bucket_name, file_name=file_name)
-    
-    def get_bucket_file_from_s3_location(s3_location: S3Location) -> S3Location:
-        return S3Location.from_location(location=s3_location)
-    
-    def save_document_content(
-        self, 
-        file_contents: bytes, 
-        file_name: str, 
-        bucket_name: str, 
-        content_encoding: str = "", 
-        content_type: str = "application/pdf",
-        compress: bool = True,
-    ) -> S3Location:
-        """
-        saves document content to bucket, in file_name
-        Options for content_type: 
-            "application/pdf"
-            "text/plain"
-            "application/json"
-            probably more
-        Options for content_encoding:
-            "": default encoding
-            "gzip": compressed contents
-        """
-        if compress or file_name.endswith(".gz"):
-            file_contents = gzip.compress(file_contents)
-            content_encoding = "gzip"
-        obj = self.client.Object(bucket_name, file_name)
-        obj.put(Body = file_contents, ContentType = content_type, ContentEncoding = content_encoding)
-        return S3Location(bucket=bucket_name, file_name=file_name)
-    
-    def read_binary_from_s3(self, s3_location: S3Location) -> bytes:
-        obj = self.client.Object(s3_location.bucket, s3_location.file_name)
-        d_bytes = io.BytesIO()
-        obj.download_fileobj(d_bytes)
-        d_bytes.seek(0)
-        if obj.content_encoding == "gzip":
-            try:
-                with gzip.GzipFile(fileobj=d_bytes) as gz_file:
-                    return gz_file.read()
-            except gzip.BadGzipFile:
-                d_bytes.seek(0)
-        return d_bytes.read()

my_aws_helpers-1.6.0/my_aws_helpers/sfn.py

@@ -1,57 +0,0 @@
-import boto3
-from typing import Optional
-import json
-from uuid import uuid4
-from my_aws_helpers.api import API
-from my_aws_helpers.errors import *
-
-class SFN:
-    client: boto3.client
-
-    def __init__(self) -> None:
-        self.client = boto3.client('stepfunctions')
-
-    def start_execution(self, sfn_arn: str, event: Optional[dict] = None, name: Optional[str] = uuid4().hex):
-        input_event = json.dumps(event) if event else event
-        return self.client.start_execution(
-            stateMachineArn = sfn_arn,
-            name = name,
-            input = input_event,
-        )
-    
-    def handle_error_response(func):
-        def wrapper(event, context):
-            try:
-                response = func(event, context)        
-                return API.response(
-                    code = 200, 
-                    body = json.dumps(response) 
-                )
-            except AlreadyExists as e:
-                return API.response(
-                    code = 201, 
-                    body = json.dumps({"Success": f"{e}"}) 
-                )                
-            except ClientError as e:
-                return API.response(
-                    code = 400, 
-                    body = json.dumps({"Error": f"{e}"}) 
-                )
-            except NotFoundError as e:
-                return API.response(
-                    code = 404, 
-                    body = json.dumps({"Error": f"{e}"}) 
-                )
-            except ServerError as e:
-                return API.response(
-                    code = 500, 
-                    body = json.dumps({"Error": f"{e}"}) 
-                )
-            except Exception as e:
-                return API.response(
-                    code = 500, 
-                    body = json.dumps({"Error": f"{e}"}) 
-                )
-        return wrapper    
-    
-