boto3-assist 0.5.2__tar.gz → 0.6.1__tar.gz

{boto3_assist-0.5.2 → boto3_assist-0.6.1}/.gitignore

@@ -163,3 +163,5 @@ cython_debug/
 
 .imports
 .env.development
+.unittest
+.unittests

{boto3_assist-0.5.2 → boto3_assist-0.6.1}/.vscode/settings.json

@@ -12,8 +12,7 @@
     "python.analysis.extraPaths": [                
         "${workspaceFolder}",
         "${workspaceFolder}/examples",
-        "${workspaceFolder}/src",
-        "${workspaceFolder}/src/boto3_assist",        
+        "${workspaceFolder}/src",                
         "${workspaceFolder}/tests",
         "${workspaceFolder}/devops",
         "${workspaceFolder}/devops/cdk",   

{boto3_assist-0.5.2 → boto3_assist-0.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boto3_assist
-Version: 0.5.2
+Version: 0.6.1
 Summary: Additional boto3 wrappers to make your life a little easier
 Author-email: Eric Wilson <boto3-assist@geekcafe.com>
 License-File: LICENSE-EXPLAINED.txt

{boto3_assist-0.5.2 → boto3_assist-0.6.1}/pyproject.toml

@@ -7,7 +7,7 @@ packages = ["src/boto3_assist"]
 
 [project]
 name = "boto3_assist"
-version = "0.5.2"
+version = "0.6.1"
 
 authors = [
   { name="Eric Wilson", email="boto3-assist@geekcafe.com" }

boto3_assist-0.6.1/run_unit_tests.sh

@@ -0,0 +1,22 @@
+#!/bin/bash
+
+python --version
+python -m venv .unittest
+source ./.unittest/bin/activate
+which python
+
+
+pip install --upgrade pip
+pip install -r ./requirements.txt
+pip install -r ./requirements-dev.txt
+
+
+echo "running unit test"
+python -m unittest discover -s tests -p "*_test.py"
+
+if [ $? -eq 0 ]; then
+    echo "Tests passed successfully"
+else
+    echo "No tests found or tests failed"
+    exit 1
+fi

{boto3_assist-0.5.2 → boto3_assist-0.6.1}/src/boto3_assist/dynamodb/dynamodb_model_base.py

@@ -6,9 +6,10 @@ MIT License.  See Project Root for the license information.
 
 from __future__ import annotations
 import datetime as dt
-import decimal
-import inspect
-import uuid
+
+# import decimal
+# import inspect
+# import uuid
 from typing import TypeVar, List, Dict, Any
 from boto3.dynamodb.types import TypeSerializer
 from boto3_assist.utilities.serialization_utility import Serialization
@@ -19,6 +20,7 @@ from boto3_assist.dynamodb.dynamodb_index import (
 )
 from boto3_assist.dynamodb.dynamodb_reserved_words import DynamoDBReservedWords
 from boto3_assist.utilities.datetime_utility import DatetimeUtility
+from boto3_assist.models.serializable_model import SerializableModel
 
 
 def exclude_from_serialization(method):
@@ -37,7 +39,7 @@ def exclude_indexes_from_serialization(method):
     return method
 
 
-class DynamoDBModelBase:
+class DynamoDBModelBase(SerializableModel):
     """DyanmoDb Model Base"""
 
     T = TypeVar("T", bound="DynamoDBModelBase")
@@ -270,7 +272,9 @@ class DynamoDBSerializer:
         return mapped
 
     @staticmethod
-    def to_client_dictionary(instance: DynamoDBModelBase, include_indexes: bool = True):
+    def to_client_dictionary(
+        instance: DynamoDBModelBase, include_indexes: bool = True
+    ) -> Dict[str, Any]:
         """
         Convert a Python class instance to a dictionary suitable for DynamoDB client.
 
@@ -281,16 +285,19 @@ class DynamoDBSerializer:
         - dict: A dictionary representation of the class instance suitable for DynamoDB client.
         """
         serializer = TypeSerializer()
-        return DynamoDBSerializer._serialize(
-            instance, serializer.serialize, include_indexes=include_indexes
-        )
+        d = Serialization.to_dict(instance, serializer.serialize)
+
+        if include_indexes:
+            d = DynamoDBSerializer._add_indexes(instance=instance, instance_dict=d)
+
+        return d
 
     @staticmethod
     def to_resource_dictionary(
         instance: DynamoDBModelBase,
         include_indexes: bool = True,
         include_none: bool = False,
-    ):
+    ) -> Dict[str, Any]:
         """
         Convert a Python class instance to a dictionary suitable for DynamoDB resource.
 
@@ -300,112 +307,16 @@ class DynamoDBSerializer:
         Returns:
         - dict: A dictionary representation of the class instance suitable for DynamoDB resource.
         """
-        return DynamoDBSerializer._serialize(
+        d = Serialization.to_dict(
             instance,
             lambda x: x,
-            include_indexes=include_indexes,
             include_none=include_none,
         )
 
-    @staticmethod
-    def _serialize(
-        instance: DynamoDBModelBase,
-        serialize_fn,
-        include_indexes: bool = True,
-        include_none: bool = True,
-    ):
-        def is_primitive(value):
-            """Check if the value is a primitive data type."""
-            return isinstance(value, (str, int, bool, type(None)))
-
-        def serialize_value(value):
-            """Serialize the value using the provided function."""
-
-            if isinstance(value, DynamoDBModelBase):
-                return serialize_fn(
-                    value.to_resource_dictionary(
-                        include_indexes=False, include_none=include_none
-                    )
-                )
-            if isinstance(value, dt.datetime):
-                return serialize_fn(value.isoformat())
-            elif isinstance(value, float):
-                v = serialize_fn(decimal.Decimal(str(value)))
-                return v
-            elif isinstance(value, decimal.Decimal):
-                return serialize_fn(value)
-            elif isinstance(value, uuid.UUID):
-                return serialize_fn(str(value))
-            elif isinstance(value, (bytes, bytearray)):
-                return serialize_fn(value.hex())
-            elif is_primitive(value):
-                return serialize_fn(value)
-            elif isinstance(value, list):
-                return serialize_fn([serialize_value(v) for v in value])
-            elif isinstance(value, dict):
-                return serialize_fn({k: serialize_value(v) for k, v in value.items()})
-            else:
-                return serialize_fn(
-                    DynamoDBSerializer._serialize(
-                        value,
-                        serialize_fn,
-                        include_indexes=include_indexes,
-                        include_none=include_none,
-                    )
-                )
-
-        instance_dict = DynamoDBSerializer._add_properties(
-            instance, serialize_value, include_none=include_none
-        )
-
         if include_indexes:
-            instance_dict = DynamoDBSerializer._add_indexes(instance, instance_dict)
-        return instance_dict
+            d = DynamoDBSerializer._add_indexes(instance=instance, instance_dict=d)
 
-    @staticmethod
-    def _add_properties(
-        instance: DynamoDBModelBase,
-        serialize_value,
-        include_none: bool = True,
-    ) -> dict:
-        instance_dict = {}
-
-        # Add instance variables
-        for attr, value in instance.__dict__.items():
-            if str(attr) == "T":
-                continue
-            # don't get the private properties
-            if not str(attr).startswith("_"):
-                if value is not None or include_none:
-                    instance_dict[attr] = serialize_value(value)
-
-        # Add properties
-        for name, _ in inspect.getmembers(
-            instance.__class__, predicate=inspect.isdatadescriptor
-        ):
-            prop = None
-            try:
-                prop = getattr(instance.__class__, name)
-            except AttributeError:
-                continue
-            if isinstance(prop, property):
-                # Exclude properties marked with the exclude_from_serialization decorator
-                # Check if the property should be excluded
-                exclude = getattr(prop.fget, "exclude_from_serialization", False)
-                if exclude:
-                    continue
-
-                # Skip TypeVar T or instances of DynamoDBModelBase
-                if str(name) == "T":
-                    continue
-
-                # don't get the private properties
-                if not str(name).startswith("_"):
-                    value = getattr(instance, name)
-                    if value is not None or include_none:
-                        instance_dict[name] = serialize_value(value)
-
-        return instance_dict
+        return d
 
     @staticmethod
     def _add_indexes(instance: DynamoDBModelBase, instance_dict: dict) -> dict:

boto3_assist-0.6.1/src/boto3_assist/models/serializable_model.py

@@ -0,0 +1,9 @@
+"""
+Geek Cafe, LLC
+Maintainers: Eric Wilson
+MIT License.  See Project Root for the license information.
+"""
+
+from __future__ import annotations
+
+from boto3_assist.utilities.serialization_utility import SerializableModel  # noqa: F401 # pylint: disable=unused-import