my-aws-helpers 3.1.0.dev4__tar.gz → 4.0.0__tar.gz

{my_aws_helpers-3.1.0.dev4 → my_aws_helpers-4.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: my_aws_helpers
-Version: 3.1.0.dev4
+Version: 4.0.0
 Summary: AWS Helpers
 Home-page: https://github.com/JarrodMccarthy/aws_helpers.git
 Author: Jarrod McCarthy
@@ -11,6 +11,8 @@ Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
+Provides-Extra: all
+Provides-Extra: bedrock
 
 UNKNOWN
 

{my_aws_helpers-3.1.0.dev4 → my_aws_helpers-4.0.0}/my_aws_helpers/api.py

@@ -10,7 +10,7 @@ class API:
         if isinstance(obj, datetime) or isinstance(obj, date):
             return obj.isoformat()
         return obj
-    
+
     def response_serialiser(response: Any):
         if isinstance(response, list):
             return [API.response_serialiser(obj) for obj in response]
@@ -18,7 +18,7 @@ class API:
             for k, v in response.items():
                 response[k] = API.response_serialiser(v)
             return response
-        return API._serialise(response)       
+        return API._serialise(response)
 
     def response(code: int, body: Optional[str] = None):
         return {

{my_aws_helpers-3.1.0.dev4 → my_aws_helpers-4.0.0}/my_aws_helpers/bedrock.py

@@ -11,6 +11,7 @@ import pymupdf
 import concurrent.futures
 from dataclasses import dataclass
 
+
 class PromptType(str, Enum):
     transaction_headers = "transactions_headers_prompt_v2.txt"
     transactions = "transactions_prompt.txt"
@@ -27,9 +28,9 @@ class TokenUsage:
     @classmethod
     def from_dict(cls, data: Dict[str, int]) -> TokenUsage:
         return cls(
-            input_tokens=data.get('inputTokens', 0),
-            output_tokens=data.get('outputTokens', 0),
-            total_tokens=data.get('totalTokens', 0),
+            input_tokens=data.get("inputTokens", 0),
+            output_tokens=data.get("outputTokens", 0),
+            total_tokens=data.get("totalTokens", 0),
         )
 
 
@@ -42,9 +43,9 @@ class OCRResult:
     @classmethod
     def from_dict(cls, data: Dict) -> OCRResult:
         return cls(
-            content = data.get("content", []),
-            token_usage = TokenUsage.from_dict(data.get("token_usage", {})),
-            page_number = data.get("page_number", 0)
+            content=data.get("content", []),
+            token_usage=TokenUsage.from_dict(data.get("token_usage", {})),
+            page_number=data.get("page_number", 0),
         )
 
 
@@ -52,7 +53,7 @@ class Bedrock:
     def __init__(
         self,
         model_id: str = "apac.anthropic.claude-3-5-sonnet-20241022-v2:0",
-        logger = None,
+        logger=None,
         sleep_time: float = 1.0,
     ):
 
@@ -60,16 +61,18 @@ class Bedrock:
         self.logger = logger
         region_name = "ap-southeast-2"
         if self.session is None:
-            self.session = boto3.Session(region_name = region_name)
+            self.session = boto3.Session(region_name=region_name)
         self.sleep_time = sleep_time
-        
+
         custom_config = Config(
             retries={
-                'max_attempts': 2,  # Total attempts = 1 initial + 1 retry
-                'mode': 'standard',  # or 'adaptive'
+                "max_attempts": 2,  # Total attempts = 1 initial + 1 retry
+                "mode": "standard",  # or 'adaptive'
             }
-        )      
-        self.client = self.session.client("bedrock-runtime", region_name=region_name, config = custom_config)
+        )
+        self.client = self.session.client(
+            "bedrock-runtime", region_name=region_name, config=custom_config
+        )
         self.model_id = model_id
 
     @staticmethod
@@ -83,7 +86,7 @@ class Bedrock:
                 aws_access_key_id=aws_access_key_id,
                 aws_secret_access_key=aws_secret_access_key,
                 aws_session_token=aws_session_token,
-                region_name=region_name
+                region_name=region_name,
             )
         except Exception as e:
             print(e)
@@ -92,7 +95,7 @@ class Bedrock:
     def _get_prompt(self, prompt_type: str) -> Optional[str]:
         if prompt_type not in list(PromptType):
             raise Exception(f"Error: Invalid prompt type")
-        
+
         path = os.path.join(os.path.dirname(__file__), "prompts", prompt_type)
         try:
             with open(path, "r") as f:
@@ -103,10 +106,7 @@ class Bedrock:
         return None
 
     def _ocr(
-        self, 
-        prompt: str, 
-        image_bytes: bytes,
-        page_number: Optional[int] = 0
+        self, prompt: str, image_bytes: bytes, page_number: Optional[int] = 0
     ) -> Optional[OCRResult]:
         system_prompt = [{"text": prompt}]
         message = [
@@ -118,36 +118,41 @@ class Bedrock:
                             "format": "png",
                             "source": {
                                 "bytes": image_bytes,
-                            }
+                            },
                         }
                     }
-                ]
+                ],
             }
         ]
         retries = 3
         for i in range(retries):
             self.logger.info(f"Attempt number {i} for {self.model_id} converse")
             try:
-                response = self.client.converse(modelId = self.model_id, messages = message, system = system_prompt)
-                if response['ResponseMetadata']['HTTPStatusCode'] == 200:
+                response = self.client.converse(
+                    modelId=self.model_id, messages=message, system=system_prompt
+                )
+                if response["ResponseMetadata"]["HTTPStatusCode"] == 200:
                     break
             except Exception as e:
                 self.logger.exception(f"Error during conversation due to {e}")
-                if i >= len(retries) - 1: raise Exception(e)
+                if i >= len(retries) - 1:
+                    raise Exception(e)
                 time.sleep(self.sleep_time)
                 continue
-        
+
         result = {}
-        result["content"] = json.loads(response["output"]["message"]["content"][0]["text"])
+        result["content"] = json.loads(
+            response["output"]["message"]["content"][0]["text"]
+        )
         result["token_usage"] = response["usage"]
         result["page_number"] = page_number
-        return OCRResult.from_dict(data = result)
-    
+        return OCRResult.from_dict(data=result)
+
     def _parallel_ocr(
-            self, 
-            image_bytes_list: List[bytes], 
-            prompt: str,
-            max_workers: int = 10,
+        self,
+        image_bytes_list: List[bytes],
+        prompt: str,
+        max_workers: int = 10,
     ):
         execution_futures = []
         with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:
@@ -158,12 +163,16 @@ class Bedrock:
                 execution_futures.append(future)
 
         # Wait for all tasks and collect results in order of submission
-        results = [future.result() for future in execution_futures if future.result() is not None]
+        results = [
+            future.result()
+            for future in execution_futures
+            if future.result() is not None
+        ]
         return results
-    
+
     def get_ocr_result(
         self,
-        pdf_bytes: io.BytesIO, 
+        pdf_bytes: io.BytesIO,
         prompt_type: str,
         zoom: int = 7,
     ) -> List[OCRResult]:
@@ -175,7 +184,9 @@ class Bedrock:
             image_bytes_list: List[bytes] = list()
             for i, p in enumerate(pages):
                 try:
-                    image_bytes: bytes = p.get_pixmap(matrix = pymupdf.Matrix(zoom, zoom)).tobytes("png")
+                    image_bytes: bytes = p.get_pixmap(
+                        matrix=pymupdf.Matrix(zoom, zoom)
+                    ).tobytes("png")
                     image_bytes_list.append(image_bytes)
                 except Exception as e:
                     self.logger.error(f"Could not get pix map for page {i}")
@@ -183,12 +194,18 @@ class Bedrock:
             skip_page_zero = False
             header_ocr_result = None
             if len(image_bytes_list) > 1:
-                headers_prompt = self._get_prompt(prompt_type=PromptType.transaction_headers.value)
+                headers_prompt = self._get_prompt(
+                    prompt_type=PromptType.transaction_headers.value
+                )
                 for i in range(2):
                     # try to get headers from the first or second page
-                    header_ocr_result = self._ocr(prompt=headers_prompt, image_bytes=image_bytes_list[i])
+                    header_ocr_result = self._ocr(
+                        prompt=headers_prompt, image_bytes=image_bytes_list[i]
+                    )
                     if header_ocr_result is None:
-                        self.logger.info(f"No ocr result returned when getting headers {PromptType.transaction_headers.value}")
+                        self.logger.info(
+                            f"No ocr result returned when getting headers {PromptType.transaction_headers.value}"
+                        )
                     headers = header_ocr_result.content.get("headers")
                     if (len(headers) < 1) or (headers is None):
                         skip_page_zero = True
@@ -198,14 +215,20 @@ class Bedrock:
 
             transactions_prompt = self._get_prompt(prompt_type=prompt_type)
             if header_ocr_result:
-                transactions_prompt = transactions_prompt.replace("#### TABLE HEADERS ####", json.dumps(header_ocr_result.content))
+                transactions_prompt = transactions_prompt.replace(
+                    "#### TABLE HEADERS ####", json.dumps(header_ocr_result.content)
+                )
 
             self.logger.info("Got Prompt")
             results = list()
 
             if skip_page_zero:
-                image_bytes_list = image_bytes_list[1:] #page zero often has account summary info
-            results = self._parallel_ocr(image_bytes_list=image_bytes_list, prompt=transactions_prompt)
+                image_bytes_list = image_bytes_list[
+                    1:
+                ]  # page zero often has account summary info
+            results = self._parallel_ocr(
+                image_bytes_list=image_bytes_list, prompt=transactions_prompt
+            )
 
             # for i, image_bytes in enumerate(image_bytes_list):
             #     self.logger.info(f"Starting OCR for page: {i}")
@@ -214,4 +237,3 @@ class Bedrock:
         except Exception as e:
             self.logger.exception(e)
             return []
-            

my_aws_helpers-4.0.0/my_aws_helpers/cognito.py

@@ -0,0 +1,124 @@
+import os
+import json
+from typing import Optional
+import boto3
+import urllib.request
+from jose import jwk, jwt
+from jose.utils import base64url_decode
+from my_aws_helpers.logging import select_powertools_logger
+
+logger = select_powertools_logger("aws-helpers-cognito")
+
+
+class Cognito:
+    client: boto3.client
+
+    def __init__(
+        self,
+        client: Optional[boto3.client] = None,
+        user_pool_id: Optional[str] = None,
+    ):
+        self.cognito_user_pool_id = (
+            user_pool_id if user_pool_id else os.environ["COGNITO_USER_POOL_ID"]
+        )
+        self.region = os.environ.get("AWS_DEFAULT_REGION", "ap-southeast-2")
+        self.client = client if client else self._get_client(region=self.region)
+
+    def _get_client(self, region: str) -> boto3.client:
+        return boto3.client("cognito-idp", region_name=region)
+
+    def _verify_signature(self):
+        pass
+
+    def _verify_audience(self):
+        pass
+
+    def _verify_token_use(self):
+        pass
+
+    def validate_token(self, token: str) -> bool:
+        try:
+            if "Bearer" in token:
+                token = token.split(" ")[-1]
+            headers = jwt.get_unverified_headers(token)
+            key_id = headers["kid"]
+            keys = self._get_keys()
+            key = next(k for k in keys if k["kid"] == key_id)
+            public_key = jwk.construct(key)
+            message, encoded_signature = token.rsplit(".", 1)
+            decoded_signature = base64url_decode(encoded_signature.encode("utf-8"))
+            if not public_key.verify(message.encode("utf-8"), decoded_signature):
+                raise Exception("Signature verification failed")
+            return True
+        except Exception as e:
+            logger.exception(f"Failed to validate token due to {e}")
+            return False
+
+    def sign_up(self, username: str, password: str, app_client_id: str):
+        try:
+            response = self.client.sign_up(
+                ClientId=app_client_id,
+                Username=username,
+                Password=password,
+                UserAttributes=[
+                    {"Name": "email", "Value": username},
+                ],
+            )
+            return response
+        except Exception as e:
+            logger.exception(f"Failed to sign up due to {e}")
+            return None
+
+    def admin_confirm_sign_up(
+        self,
+        username: str,
+        user_pool_id: str,
+    ) -> dict:
+        try:
+            response = self.client.admin_confirm_sign_up(
+                UserPoolId=user_pool_id, Username=username
+            )
+            return response
+        except Exception as e:
+            logger.exception(
+                f"Failed to confirm admin sign up username {username} due to {e}"
+            )
+            return None
+
+    def refresh_token(self, refresh_token: str, app_client_id: str):
+        response = self.client.initiate_auth(
+            ClientId=app_client_id,
+            AuthFlow="REFRESH_TOKEN_AUTH",
+            AuthParameters={"REFRESH_TOKEN": refresh_token},
+        )
+        return response
+
+    def login(self, username: str, password: str, app_client_id: str):
+        response = self.client.initiate_auth(
+            ClientId=app_client_id,
+            AuthFlow="USER_PASSWORD_AUTH",
+            AuthParameters={"USERNAME": username, "PASSWORD": password},
+        )
+        return response
+
+    def _get_issuer(self) -> str:
+        return f"https://cognito-idp.{self.region}.amazonaws.com/{self.cognito_user_pool_id}"
+
+    def _get_keys(self):
+        issuer = self._get_issuer()
+        keys_url = f"{issuer}/.well-known/jwks.json"
+        with urllib.request.urlopen(keys_url) as f:
+            response = f.read()
+            keys = json.loads(response.decode("utf-8"))["keys"]
+        return keys
+
+    @staticmethod
+    def get_policy(allow: bool, method_arn: str = "*") -> dict:
+        allow = "Allow" if allow else "Deny"
+        return {
+            "principalId": "authenticated-user",
+            "policyDocument": {
+                "Version": "2012-10-17",
+                "Statement": [{"Action": "*", "Effect": allow, "Resource": "*"}],
+            },
+        }

{my_aws_helpers-3.1.0.dev4 → my_aws_helpers-4.0.0}/my_aws_helpers/dynamo.py

@@ -2,12 +2,13 @@ from typing import List, Any, Optional
 from datetime import datetime, date
 import boto3
 from abc import ABC, abstractmethod
-from decimal import Decimal, Context 
+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,
@@ -76,7 +77,6 @@ class BaseTableObject:
 
     def __init__(self) -> None:
         pass
-        
 
 
 class DynamoSerialiser:
@@ -86,10 +86,10 @@ class DynamoSerialiser:
         if isinstance(obj, datetime) or isinstance(obj, date):
             return obj.isoformat()
         if isinstance(obj, float):
-            ctx = Context(prec = 38)
+            ctx = Context(prec=38)
             return ctx.create_decimal_from_float(obj)
         return obj
-    
+
     @staticmethod
     def object_serialiser(obj: Any):
         if isinstance(obj, list):
@@ -98,6 +98,7 @@ class DynamoSerialiser:
             return {k: DynamoSerialiser.object_serialiser(v) for k, v in obj.items()}
         return DynamoSerialiser._serialise(obj=obj)
 
+
 class Dynamo:
     table: boto3.resource
 
@@ -130,14 +131,16 @@ class Dynamo:
         response = self.table.scan()
         items: List = response["Items"]
         while response.get("LastEvaluatedKey") is not None:
-            response = self.table.scan(ExclusiveStartKey = response["LastEvaluatedKey"])
+            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:
+    def delete_table_items(
+        self, partition_key_name: str = "pk", sort_key_name: str = "sk"
+    ) -> bool:
         try:
             items = self._deep_scan()
             delete_repr_items = [
@@ -147,10 +150,10 @@ class Dynamo:
                 }
                 for item in items
             ]
-            self.batch_delete(items = delete_repr_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}')
+            logger.exception(f"Failed to delete table items due to {e}")
             return False
 
     def to_dynamo_representation(obj: dict):
@@ -177,6 +180,7 @@ def _datatype_map(value: Any):
         return new_obj
     return value
 
+
 class BaseQueries(ABC):
     table_name: str
 
@@ -186,7 +190,7 @@ class BaseQueries(ABC):
 
     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"
@@ -198,4 +202,4 @@ class BaseQueries(ABC):
             results += result["Items"]
             last_evaluated_key = result.get("LastEvaluatedKey")
             exclusive_start_key = last_evaluated_key
-        return results
+        return results

{my_aws_helpers-3.1.0.dev4 → my_aws_helpers-4.0.0}/my_aws_helpers/event.py

@@ -7,14 +7,15 @@ from copy import copy
 from boto3.dynamodb.conditions import Key
 from my_aws_helpers.dynamo import BaseTableObject, DynamoSerialiser, BaseQueries, Dynamo
 
+
 class EventDynamoKeys:
     @staticmethod
     def get_event_pk(id: str):
         return f"id##{id}"
-    
+
     @staticmethod
     def get_event_sk(id: str):
-        return f"id##{id}"    
+        return f"id##{id}"
 
 
 class EventStatus(str, Enum):
@@ -40,7 +41,9 @@ class Event(BaseTableObject):
         self.status: str = self.set_status(status=status)
         self.message: str = message
         self.id: str = id if id else uuid4().hex
-        self.created_timestamp: datetime = created_timestamp if created_timestamp else datetime.now()
+        self.created_timestamp: datetime = (
+            created_timestamp if created_timestamp else datetime.now()
+        )
 
     def set_status(self, status: str) -> str:
         if status not in list(EventStatus):
@@ -49,9 +52,9 @@ class Event(BaseTableObject):
 
     def _get_pk(self):
         return EventDynamoKeys.get_event_pk(self.id)
-    
+
     def _get_sk(self):
-        return EventDynamoKeys.get_event_sk(self.id)  
+        return EventDynamoKeys.get_event_sk(self.id)
 
     @classmethod
     def _from_dynamo_representation(cls, obj: dict):
@@ -59,8 +62,8 @@ class Event(BaseTableObject):
         Deserialises this object from Dynamo Representation
         """
         this_obj = copy(obj)
-        this_obj.pop('pk')
-        this_obj.pop('sk')
+        this_obj.pop("pk")
+        this_obj.pop("sk")
         return cls(**this_obj)
 
     def _to_dynamo_representation(self):
@@ -68,8 +71,8 @@ class Event(BaseTableObject):
         Serialises this object to Dynamo Representation
         """
         obj = copy(vars(self))
-        obj['pk'] = self._get_pk()
-        obj['sk'] = self._get_sk()
+        obj["pk"] = self._get_pk()
+        obj["sk"] = self._get_sk()
         return DynamoSerialiser.object_serialiser(obj=obj)
 
 
@@ -78,11 +81,11 @@ class EventQueries(BaseQueries):
         super().__init__(table_name, client)
 
     def put_event(self, event: Event) -> Event:
-        response = self.client.put_item(item = event._to_dynamo_representation())
+        response = self.client.put_item(item=event._to_dynamo_representation())
         if response["ResponseMetadata"]["HTTPStatusCode"] == 200:
             return event
         raise Exception(f"Failed to put object into dynamo table")
-    
+
     def get_event_by_id(self, id: str):
         pk = EventDynamoKeys.get_event_pk(id=id)
         sk = EventDynamoKeys.get_event_sk(id=id)
@@ -93,5 +96,4 @@ class EventQueries(BaseQueries):
             return None
         if len(results["Items"]) > 1:
             raise Exception(f"Should only be 1 event with id {id}")
-        return Event._from_dynamo_representation(obj = results["Items"][0])
-
+        return Event._from_dynamo_representation(obj=results["Items"][0])

{my_aws_helpers-3.1.0.dev4 → my_aws_helpers-4.0.0}/my_aws_helpers/s3.py

@@ -51,7 +51,11 @@ class S3:
         resource: Optional[boto3.resource] = None,
     ) -> None:
         self.client = client if client else self._get_client()
-        self.resource = resource if resource else boto3.resource('s3')
+        self.resource = (
+            resource
+            if resource
+            else boto3.resource("s3", region_name=os.environ["AWS_DEFAULT_REGION"])
+        )
 
     def _get_client(self) -> boto3.client:
         region_name = os.environ["AWS_DEFAULT_REGION"]
@@ -77,7 +81,10 @@ class S3:
         return self._streaming_body_to_dict(response["Body"])
 
     def get_presigned_url(
-        self, bucket_name: str, file_name: str, expires_in: int = 3600
+        self,
+        bucket_name: str,
+        file_name: str,
+        expires_in: int = 3600,
     ):
         return self.client.generate_presigned_url(
             "get_object",
@@ -128,7 +135,7 @@ class S3:
             return s3_location
         except Exception as e:
             logger.exception(e)
-            return None        
+            return None
 
     def read_binary_from_s3(self, s3_location: S3Location) -> Optional[bytes]:
         try:

{my_aws_helpers-3.1.0.dev4 → my_aws_helpers-4.0.0}/my_aws_helpers.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: my-aws-helpers
-Version: 3.1.0.dev4
+Version: 4.0.0
 Summary: AWS Helpers
 Home-page: https://github.com/JarrodMccarthy/aws_helpers.git
 Author: Jarrod McCarthy
@@ -11,6 +11,8 @@ Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
+Provides-Extra: all
+Provides-Extra: bedrock
 
 UNKNOWN
 

{my_aws_helpers-3.1.0.dev4 → my_aws_helpers-4.0.0}/my_aws_helpers.egg-info/SOURCES.txt

@@ -23,4 +23,5 @@ my_aws_helpers/prompts/markdown_system_prompt.txt
 my_aws_helpers/prompts/transactions_headers_prompt.txt
 my_aws_helpers/prompts/transactions_headers_prompt_v2.txt
 my_aws_helpers/prompts/transactions_prompt.txt
+tests/test_cognito.py
 tests/test_event.py

my_aws_helpers-4.0.0/my_aws_helpers.egg-info/requires.txt

@@ -0,0 +1,15 @@
+boto3==1.34.36
+python-jose==3.5.0
+
+[all]
+PyMuPDF==1.26.0
+black<26.0.0,<=25.1.0
+boto3==1.34.36
+coverage==7.3.2
+pytest==7.4.3
+python-jose==3.5.0
+
+[bedrock]
+PyMuPDF==1.26.0
+boto3==1.34.36
+python-jose==3.5.0

{my_aws_helpers-3.1.0.dev4 → my_aws_helpers-4.0.0}/setup.py

@@ -3,7 +3,19 @@ from setuptools import find_namespace_packages, setup
 
 base_path = os.path.abspath(os.path.dirname(__file__))
 
-version = "3.1.0.dev4"
+version = "4.0.0"
+
+core = [
+    "boto3==1.34.36",
+    "python-jose==3.5.0",
+]
+dev = [
+    "pytest==7.4.3",
+    "coverage==7.3.2",
+    "black<=25.1.0,<26.0.0",
+]
+bedrock = ["PyMuPDF==1.26.0"]
+all = dev + core + bedrock
 
 setup(
     name="my_aws_helpers",
@@ -12,7 +24,11 @@ setup(
     description="AWS Helpers",
     url="https://github.com/JarrodMccarthy/aws_helpers.git",
     platforms="any",
-    packages=[p for p in find_namespace_packages(where=base_path) if p.startswith("my_aws_helpers")],
+    packages=[
+        p
+        for p in find_namespace_packages(where=base_path)
+        if p.startswith("my_aws_helpers")
+    ],
     classifiers=[
         "License :: Other/Proprietary License",
         "Programming Language :: Python",
@@ -20,9 +36,8 @@ setup(
         "Programming Language :: Python :: 3.9",
         "Programming Language :: Python :: 3.10",
     ],
-    zip_safe = True,
-    install_requires = [
-        "boto3==1.34.36"
-    ],
+    zip_safe=True,
+    install_requires=core,
     include_package_data=True,
-)
+    extras_require={"bedrock": core + bedrock, "all": all},
+)

my_aws_helpers-4.0.0/tests/test_cognito.py

@@ -0,0 +1,20 @@
+import os
+from aws_lambda_powertools.logging import Logger
+
+
+def test_init():
+    from my_aws_helpers.cognito import Cognito
+
+    os.environ["COGNITO_USER_POOL_ID"] = "fake-pool-id"
+    cognito = Cognito()
+    assert isinstance(cognito, Cognito) == True
+
+
+def test_init_with_powertools_logger():
+    os.environ["POWERTOOLS_SERVICE_NAME"] = "handler-logger"
+    logger = Logger(service=os.environ["POWERTOOLS_SERVICE_NAME"])
+    from my_aws_helpers.cognito import Cognito
+
+    os.environ["COGNITO_USER_POOL_ID"] = "fake-pool-id"
+    cognito = Cognito()
+    assert isinstance(cognito, Cognito) == True

{my_aws_helpers-3.1.0.dev4 → my_aws_helpers-4.0.0}/tests/test_event.py

@@ -6,18 +6,19 @@ def test_event():
     event = Event(status=EventStatus.success.value, message="test event")
     assert event != None
 
+
 def test_event_wrong_status():
     with pytest.raises(Exception):
         Event(status="not success", message="test event")
 
+
 def test_serialiser():
     event = Event(status=EventStatus.success.value, message="test event")
     dynamo_repr = event._to_dynamo_representation()
 
-    assert dynamo_repr['pk'] == f"id##{event.id}"
-    assert dynamo_repr['sk'] == f"id##{event.id}"
+    assert dynamo_repr["pk"] == f"id##{event.id}"
+    assert dynamo_repr["sk"] == f"id##{event.id}"
 
-    obj = Event._from_dynamo_representation(obj = dynamo_repr)
+    obj = Event._from_dynamo_representation(obj=dynamo_repr)
 
     assert isinstance(obj, Event) == True
-        

my_aws_helpers-3.1.0.dev4/my_aws_helpers/cognito.py

@@ -1,144 +0,0 @@
-# import boto3
-# from authlib.jose import jwt
-# import requests
-# import json
-
-# class Cognito:
-#     def __init__(self, pool_id: str, client_id: str) -> None:
-#         self.pool_id = pool_id
-#         self.client_id = client_id
-#         self.client = boto3.client('cognito-idp')
-#         self.cognito_pool_domain_url = None
-#         self.cognito_known_tokens_url = None
-
-#     def delete_user(self, username: str):
-#         try:
-#             response = self.client.admin_delete_user(
-#             UserPoolId=self.pool_id,
-#             Username=username
-#             )
-#             return response
-#         except Exception as e:
-#             raise Exception(f"Error {e}: Failed to delete User {username}")
-
-#     def create_user(self, user: User):
-#         try:
-#             response = self.client.admin_create_user(
-#                 UserPoolId= self.pool_id,
-#                 Username = user.email,
-#                 UserAttributes=[
-#                     {
-#                         'Name': 'Given Name',
-#                         'Value': user.first,
-#                         'Name': 'Family Name',
-#                         'Value': user.last,
-#                         'Name': 'Full Name',
-#                         'Value': user.fullname,
-#                         'Name': 'name',
-#                         'Value': user.fullname,
-#                         'Name': 'nickname',
-#                         'Value': user.nickname,
-#                         'Name': 'email',
-#                         'Value': user.email
-#                     },
-#                 ],
-#                 ValidationData=[
-#                      {
-#                         'Name': 'Given Name',
-#                         'Value': user.first,
-#                         'Name': 'Family Name',
-#                         'Value': user.last,
-#                         'Name': 'Full Name',
-#                         'Value': user.fullname,
-#                         'Name': 'name',
-#                         'Value': user.fullname,
-#                         'Name': 'nickname',
-#                         'Value': user.nickname,
-#                         'Name': 'email',
-#                         'Value': user.email
-#                     },
-#                 ],
-#                 TemporaryPassword=user.password, #should come from user
-#                 ForceAliasCreation=False,
-#                 MessageAction='SUPPRESS',
-#                 DesiredDeliveryMediums=[
-#                     'EMAIL',
-#                 ],
-#                 ClientMetadata={
-#                     'string': 'string'
-#                 }
-#             )
-#             return response
-#         except Exception as e:
-#             raise Exception(f"Error {e}: Could not create user {user.fullname}")
-
-#     def _init_auth(self, cognito_username: str, user: User):
-#         """Initiate Auth (SRP) -> Returns Challenge"""
-#         try:
-#             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,
-#                     'name': user.fullname,
-#                     'email':user.email,
-#                     'PASSWORD': user.password
-#                 },
-#                 ClientId=self.client_id,
-#             )
-#             return response
-#         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):
-#         """Respond to Auth Challenge -> Cognito Tokens"""
-#         try:
-#             cognito_username = init_auth_response["ChallengeParameters"].get('USER_ID_FOR_SRP') #needs testing
-#             cn = init_auth_response["ChallengeName"]
-#             sess = init_auth_response["Session"]
-#             challenge_params = init_auth_response["ChallengeParameters"]
-#             challenge_resp = {
-#                     'USERNAME': user.email,
-#                     'userAttributes.name': user.fullname,
-#                     'NEW_PASSWORD':user.password
-#                 }
-#             response = self.client.respond_to_auth_challenge(
-#                 ClientId=self.client_id,
-#                 ChallengeName=cn,
-#                 Session=sess,
-#                 ChallengeResponses=challenge_resp
-#             )
-#             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):
-#     #     response = self.create_user(user)
-#     #     cognito_username = response['User'].get('Username')
-#     #     get_token_response = self.get_token(user, cognito_username)
-#     #     return get_token_response
-
-#     # def get_JWT_from_code(self, code):
-#     #     try:
-#     #         payload=f'grant_type=authorization_code&client_id={self.client_id}&code={code}'#&redirect_uri={call_back_uri}
-#     #         headers = {
-#     #         'Content-Type': 'application/x-www-form-urlencoded',
-#     #         }
-#     #         response = requests.request("POST", self.cognito_pool_domain, headers=headers, data=payload)
-#     #         tokens = json.loads(response.text)
-#     #         return tokens
-#     #     except Exception as e:
-#     #         raise Exception(f"Error {e}: Couldn't get JWT from auth code")
-
-#     # def code_to_jwt_dict(self, code):
-#     #     tokens = self.code_to_JWT(code)
-#     #     refresh_token = tokens['refresh_token']
-#     #     access_token = tokens['access_token']
-#     #     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

my_aws_helpers-3.1.0.dev4/my_aws_helpers.egg-info/requires.txt

@@ -1 +0,0 @@
-boto3==1.34.36