boto3-assist 0.1.14__py3-none-any.whl → 0.2.1__py3-none-any.whl

boto3_assist/dynamodb/dynamodb.py

@@ -5,7 +5,7 @@ MIT License.  See Project Root for the license information.
 """
 
 import os
-from typing import List, Optional, overload
+from typing import List, Optional, overload, Dict, Any
 
 from aws_lambda_powertools import Tracer, Logger
 from boto3.dynamodb.conditions import (
@@ -77,7 +77,7 @@ class DynamoDB(DynamoDBConnection):
             dict: The Response from DynamoDB's put_item actions.
             It does not return the saved object, only the response.
         """
-        response = None
+        response: Dict[str, Any] = {}
 
         try:
             if not isinstance(item, dict):
@@ -93,13 +93,13 @@ class DynamoDB(DynamoDBConnection):
 
             if isinstance(item, dict) and isinstance(next(iter(item.values())), dict):
                 # Use boto3.client syntax
-                response = self.dynamodb_client.put_item(
-                    TableName=table_name, Item=item
+                response = dict(
+                    self.dynamodb_client.put_item(TableName=table_name, Item=item)
                 )
             else:
                 # Use boto3.resource syntax
                 table = self.dynamodb_resource.Table(table_name)
-                response = table.put_item(Item=item)
+                response = dict(table.put_item(Item=item))  # type: ignore[arg-type]
 
         except Exception as e:  # pylint: disable=w0718
             logger.exception(
@@ -117,7 +117,7 @@ class DynamoDB(DynamoDBConnection):
 
         if self.log_dynamodb_item_size:
             size_bytes: int = StringUtility.get_size_in_bytes(item)
-            size_kb: int = StringUtility.get_size_in_kb(item)
+            size_kb: float = StringUtility.get_size_in_kb(item)
             logger.info({"item_size": {"bytes": size_bytes, "kb": f"{size_kb:.2f}kb"}})
 
             if size_kb > 390:
@@ -144,7 +144,7 @@ class DynamoDB(DynamoDBConnection):
         expression_attribute_names: Optional[dict] = None,
         source: Optional[str] = None,
         call_type: str = "resource",
-    ) -> dict: ...
+    ) -> Dict[str, Any]: ...
 
     @overload
     def get(
@@ -158,7 +158,7 @@ class DynamoDB(DynamoDBConnection):
         expression_attribute_names: Optional[dict] = None,
         source: Optional[str] = None,
         call_type: str = "resource",
-    ) -> dict: ...
+    ) -> Dict[str, Any]: ...
 
     @tracer.capture_method
     def get(
@@ -173,7 +173,7 @@ class DynamoDB(DynamoDBConnection):
         expression_attribute_names: Optional[dict] = None,
         source: Optional[str] = None,
         call_type: str = "resource",
-    ) -> dict:
+    ) -> Dict[str, Any]:
         """
         Description:
             generic get_item dynamoDb call
@@ -186,12 +186,15 @@ class DynamoDB(DynamoDBConnection):
             if table_name is None:
                 raise ValueError("table_name must be provided when model is used.")
             if key is not None:
-                raise ValueError("key cannot be provided when model is used.")
+                raise ValueError(
+                    "key cannot be provided when model is used. "
+                    "When using the model, we'll automatically use the key defined."
+                )
             key = model.indexes.primary.key()
             if do_projections:
                 projection_expression = model.projection_expression
                 expression_attribute_names = model.projection_expression_attribute_names
-        elif key is None or table_name is None:
+        elif key is None and model is None:
             raise ValueError("Either 'key'  or 'model'  must be provided.")
 
         response = None
@@ -205,12 +208,18 @@ class DynamoDB(DynamoDBConnection):
             # only pass in args that aren't none
             valid_kwargs = {k: v for k, v in kwargs.items() if v is not None}
 
+            if table_name is None:
+                raise ValueError("table_name must be provided.")
             if call_type == "resource":
                 table = self.dynamodb_resource.Table(table_name)
-                response = table.get_item(Key=key, **valid_kwargs)
+                response = dict(table.get_item(Key=key, **valid_kwargs))  # type: ignore[arg-type]
             elif call_type == "client":
-                response = self.dynamodb_client.get_item(
-                    Key=key, TableName=table_name, **valid_kwargs
+                response = dict(
+                    self.dynamodb_client.get_item(
+                        Key=key,
+                        TableName=table_name,
+                        **valid_kwargs,  # type: ignore[arg-type]
+                    )
                 )
             else:
                 raise ValueError(
@@ -246,10 +255,12 @@ class DynamoDB(DynamoDBConnection):
             dict: dynamodb response dictionary
         """
         table = self.dynamodb_resource.Table(table_name)
-        response = table.update_item(
-            Key=key,
-            UpdateExpression=update_expression,
-            ExpressionAttributeValues=expression_attribute_values,
+        response = dict(
+            table.update_item(
+                Key=key,
+                UpdateExpression=update_expression,
+                ExpressionAttributeValues=expression_attribute_values,
+            )
         )
 
         return response
@@ -307,7 +318,7 @@ class DynamoDB(DynamoDBConnection):
             raise ValueError("Query failed: table_name must be provided.")
 
         table = self.dynamodb_resource.Table(table_name)
-        response = table.query(**kwargs)
+        response = dict(table.query(**kwargs))
 
         return response
 

boto3_assist/dynamodb/dynamodb_connection.py

@@ -92,10 +92,13 @@ class DynamoDBConnection:
         """Session"""
         if self.__session is None:
             self.setup(setup_source="session init")
+
+        if self.__session is None:
+            raise RuntimeError("Session is not available")
         return self.__session
 
     @property
-    def dynamodb_client(self) -> DynamoDBClient:
+    def client(self) -> DynamoDBClient:
         """DynamoDB Client Connection"""
         if self.__dynamodb_client is None:
             logger.info("Creating DynamoDB Client")
@@ -105,13 +108,26 @@ class DynamoDBConnection:
             raise RuntimeError("DynamoDB Client is not available")
         return self.__dynamodb_client
 
+    @client.setter
+    def client(self, value: DynamoDBClient):
+        logger.info("Setting DynamoDB Client")
+        self.__dynamodb_client = value
+
+    @property
+    def dynamodb_client(self) -> DynamoDBClient:
+        """
+        DynamoDB Client Connection
+            - Backward Compatible.  You should use client instead
+        """
+        return self.client
+
     @dynamodb_client.setter
     def dynamodb_client(self, value: DynamoDBClient):
         logger.info("Setting DynamoDB Client")
         self.__dynamodb_client = value
 
     @property
-    def dynamodb_resource(self) -> DynamoDBServiceResource:
+    def resource(self) -> DynamoDBServiceResource:
         """DynamoDB Resource Connection"""
         if self.__dynamodb_resource is None:
             logger.info("Creating DynamoDB Resource")
@@ -122,6 +138,19 @@ class DynamoDBConnection:
 
         return self.__dynamodb_resource
 
+    @resource.setter
+    def resource(self, value: DynamoDBServiceResource):
+        logger.info("Setting DynamoDB Resource")
+        self.__dynamodb_resource = value
+
+    @property
+    def dynamodb_resource(self) -> DynamoDBServiceResource:
+        """
+        DynamoDB Resource Connection
+            - Backward Compatible.  You should use resource instead
+        """
+        return self.resource
+
     @dynamodb_resource.setter
     def dynamodb_resource(self, value: DynamoDBServiceResource):
         logger.info("Setting DynamoDB Resource")

boto3_assist/dynamodb/dynamodb_index.py

@@ -34,6 +34,33 @@ class DynamoDBIndexes:
         """Add a GSI/LSI index"""
         if index.name is None:
             raise ValueError("Index name cannot be None")
+
+        # if the index already exists, raise an exception
+        if index.name in self.__indexes:
+            raise ValueError(f"Index {index.name} already exists")
+        if index.name == DynamoDBIndexes.PRIMARY_INDEX:
+            raise ValueError(f"Index {index.name} is reserved for the primary index")
+        if index.partition_key is None:
+            raise ValueError("Index must have a partition key")
+
+        # check if the index.partition_key.attribute_name is already in the index
+        for _, v in self.__indexes.items():
+            if v.partition_key.attribute_name == index.partition_key.attribute_name:
+                raise ValueError(
+                    f"The attrubute {index.partition_key.attribute_name} is already being used by index "
+                    f"{v.name}. "
+                    f"Reusing this attribute would over write the value on index {v.name}"
+                )
+        # check if the gsi1.sort_key.attribute_name exists
+        if index.sort_key is not None:
+            for _, v in self.__indexes.items():
+                if v.sort_key.attribute_name == index.sort_key.attribute_name:
+                    raise ValueError(
+                        f"The attrubute {index.sort_key.attribute_name} is already being used by index "
+                        f"{v.name}. "
+                        f"Reusing this attribute would over write the value on index {v.name}"
+                    )
+
         self.__indexes[index.name] = index
 
     def get(self, index_name: str) -> DynamoDBIndex:

boto3_assist/dynamodb/dynamodb_iservice.py

@@ -7,6 +7,10 @@ from boto3_assist.dynamodb.dynamodb_model_base import DynamoDBModelBase
 class IDynamoDBService(ABC):
     """DynamoDB Service Interface"""
 
+    def __init__(self, db: DynamoDB) -> None:
+        self.db = db
+        super().__init__()
+
     @property
     @abstractmethod
     def db(self) -> DynamoDB:

boto3_assist/dynamodb/dynamodb_model_base.py

@@ -9,8 +9,7 @@ import datetime as dt
 import decimal
 import inspect
 import uuid
-
-from typing import TypeVar, List
+from typing import TypeVar, List, Dict, Any
 from boto3.dynamodb.types import TypeSerializer
 from boto3_assist.utilities.serialization_utility import Serialization
 from boto3_assist.dynamodb.dynamodb_helpers import DynamoDBHelpers
@@ -82,6 +81,10 @@ class DynamoDBModelBase:
 
         return self.__projection_expression
 
+    @projection_expression.setter
+    def projection_expression(self, value: str | None):
+        self.__projection_expression = value
+
     @property
     @exclude_from_serialization
     def auto_generate_projections(self) -> bool:
@@ -92,10 +95,6 @@ class DynamoDBModelBase:
     def auto_generate_projections(self, value: bool):
         self.__auto_generate_projections = value
 
-    @projection_expression.setter
-    def projection_expression(self, value: str | None):
-        self.__projection_expression = value
-
     @property
     @exclude_from_serialization
     def projection_expression_attribute_names(self) -> dict | None:
@@ -126,7 +125,7 @@ class DynamoDBModelBase:
     def projection_expression_attribute_names(self, value: dict | None):
         self.__projection_expression_attribute_names = value
 
-    def map(self: T, item: dict | DynamoDBModelBase | None) -> T | None:
+    def map(self: T, item: Dict[str, Any] | DynamoDBModelBase | None) -> T | None:
         """
         Map the item to the instance.  If the item is a DynamoDBModelBase,
         it will be converted to a dictionary first and then mapped.

boto3_assist/dynamodb/dynamodb_reserved_words.py

@@ -3,7 +3,10 @@ from typing import List
 
 
 class DynamoDBReservedWords:
-    """Reserved Word"""
+    """
+    Reserved Words used by DynamoDB that can cause issues,
+    so they will need to be transformed under certain conditions, such as when doing projections
+    """
 
     def __init__(self) -> None:
         self.__list: List[str] = self.__read_list()
@@ -35,9 +38,9 @@ class DynamoDBReservedWords:
         projections = ["#" + p if self.is_reserved_word(p) else p for p in projections]
         return projections
 
-    def transform_attributes(self, projections: List[str] | str) -> dict:
+    def transform_attributes(self, projections: List[str] | str) -> dict | None:
         """Transforms a dict of attributes to remove reserved words"""
-        transformed_attributes: dict | None = {}
+        transformed_attributes: dict = {}
         if isinstance(projections, str):
             projections = projections.split(",")
         for item in projections:

boto3_assist/dynamodb/dynamodb_reserved_words.txt

@@ -1,4 +1,3 @@
-
 ABORT
 ABSOLUTE
 ACTION

boto3_assist/ec2/ec2_connection.py

@@ -84,6 +84,9 @@ class EC2Connection:
         """Session"""
         if self.__session is None:
             self.setup(setup_source="session init")
+
+        if self.__session is None:
+            raise RuntimeError("Session is not available")
         return self.__session
 
     @property

boto3_assist/environment_services/environment_loader.py

@@ -1,22 +1,42 @@
+"""
+Geek Cafe, LLC
+Maintainers: Eric Wilson
+MIT License.  See Project Root for the license information.
+"""
+
 import os
-from typing import IO, Optional, Union
+
+from typing import List, Union, Optional, IO
+from pathlib import Path
 from dotenv import load_dotenv
+from aws_lambda_powertools import Logger
+
+
+logger = Logger(__name__)
+
+DEBUGGING = os.getenv("DEBUGGING", "false").lower() == "true"
 
 StrPath = Union[str, "os.PathLike[str]"]
 
 
 class EnvironmentLoader:
+    """Environment Loader"""
+
     def __init__(self) -> None:
         pass
 
     def load_environment_file(
         self,
+        *,
+        starting_path: Optional[str] = None,
+        file_name: Optional[str] = None,
         path: Optional[StrPath] = None,
         stream: Optional[IO[str]] = None,
         verbose: bool = False,
         override: bool = True,
         interpolate: bool = True,
         encoding: Optional[str] = "utf-8",
+        raise_error_if_not_found: bool = False,
     ) -> bool:
         """
         Loads an environment file into memory. This simply passes off to load_dotenv in dotenv.
@@ -37,11 +57,55 @@ class EnvironmentLoader:
         If both `dotenv_path` and `stream` are `None`, `find_dotenv()` is used to find the
         .env file.
         """
-        return load_dotenv(
-            dotenv_path=path,
+
+        if not starting_path:
+            starting_path = __file__
+
+        if file_name is None:
+            file_name = ".env"
+
+        new_path: str | StrPath | None = path or self.find_file(
+            starting_path=starting_path,
+            file_name=file_name,
+            raise_error_if_not_found=raise_error_if_not_found,
+        )
+
+        loaded = load_dotenv(
+            dotenv_path=new_path,
             stream=stream,
             verbose=verbose,
             override=override,
             interpolate=interpolate,
             encoding=encoding,
         )
+
+        if DEBUGGING:
+            env_vars = os.environ
+            logger.debug(f"Loaded environment file: {path}")
+            print(env_vars)
+
+        return loaded
+
+    def find_file(
+        self, starting_path: str, file_name: str, raise_error_if_not_found: bool = True
+    ) -> str | None:
+        """Searches the project directory structor for a file"""
+        parents = 10
+        starting_path = starting_path or __file__
+
+        paths: List[str] = []
+        for parent in range(parents):
+            path = Path(starting_path).parents[parent].absolute()
+            print(f"searching: {path}")
+            tmp = os.path.join(path, file_name)
+            paths.append(tmp)
+            if os.path.exists(tmp):
+                return tmp
+
+        if raise_error_if_not_found:
+            searched_paths = "\n".join(paths)
+            raise RuntimeError(
+                f"Failed to locate environment file: {file_name} in: \n {searched_paths}"
+            )
+
+        return None

boto3_assist/environment_services/environment_variables.py

@@ -27,6 +27,8 @@ class EnvironmentVariables:
             gets the aws region from an environment var
             """
             value = os.getenv("AWS_REGION")
+            if not value:
+                value = None
             return value
 
         @staticmethod
@@ -36,6 +38,8 @@ class EnvironmentVariables:
             This should only be set with temporty creds and only for development purposes
             """
             value = os.getenv("AWS_PROFILE")
+            if not value:
+                value = None
             return value
 
         @staticmethod

boto3_assist/errors/custom_exceptions.py

@@ -0,0 +1,34 @@
+class Error(Exception):
+    """Base class for exceptions in this module."""
+
+
+class DbFailures(Error):
+    """DB Failure Error"""
+
+
+class InvalidHttpMethod(Exception):
+    """Invalid Http Method"""
+
+    def __init__(
+        self,
+        code=422,
+        message="Invalid Http Method",
+    ):
+        """The user account is not valid"""
+        self.message = {
+            "status_code": code,
+            "message": message,
+        }
+        super().__init__(self.message)
+
+
+class InvalidRoutePath(Exception):
+    """Invalid Http Route"""
+
+    def __init__(self, message="Invalid Route"):
+        """Invalid Route"""
+        self.message = {
+            "status_code": 404,
+            "message": message,
+        }
+        super().__init__(self.message)