boto3-assist 0.5.1__tar.gz → 0.6.0__tar.gz

{boto3_assist-0.5.1 → boto3_assist-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boto3_assist
-Version: 0.5.1
+Version: 0.6.0
 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.1 → boto3_assist-0.6.0}/pyproject.toml

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

{boto3_assist-0.5.1 → boto3_assist-0.6.0}/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.0/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 typing import TypeVar, Dict, Any
+from boto3_assist.utilities.serialization_utility import SerializableModel

{boto3_assist-0.5.1 → boto3_assist-0.6.0}/src/boto3_assist/utilities/serialization_utility.py

@@ -2,17 +2,58 @@
 
 from datetime import datetime
 from decimal import Decimal
-from typing import Dict, List, TypeVar
+from typing import Dict, List, TypeVar, Any
 import json
 import jsons
+import datetime as dt
+import decimal
+import inspect
+import uuid
 from aws_lambda_powertools import Logger
 
+
 T = TypeVar("T")
 
 
 logger = Logger()
 
 
+class SerializableModel:
+    """Library to Serialize object to a DynamoDB Format"""
+
+    T = TypeVar("T", bound="SerializableModel")
+
+    def __init__(self):
+        pass
+
+    def map(
+        self: T,
+        source: Dict[str, Any] | "SerializableModel" | None,
+        coerce: bool = True,
+    ) -> T:
+        """
+        Map the source dictionary to the target object.
+
+        Args:
+        - source: The dictionary to map from.
+        - target: The object to map to.
+        """
+        mapped = Serialization.map(source=source, target=self, coerce=coerce)
+        if mapped is None:
+            raise ValueError("Unable to map source to target")
+
+        return mapped
+
+    def to_dictionary(self) -> Dict[str, Any]:
+        """
+        Convert the object to a dictionary.
+        """
+        # return Serialization.convert_object_to_dict(self)
+        return Serialization.to_dict(
+            instance=self, serialize_fn=lambda x: x, include_none=True
+        )
+
+
 class JsonEncoder(json.JSONEncoder):
     """
     This class is used to serialize python generics which implement a __json_encode__ method
@@ -52,7 +93,7 @@ class JsonEncoder(json.JSONEncoder):
 
 class Serialization:
     """
-    Serliaztion Class
+    Serialization Class
     """
 
     @staticmethod
@@ -60,11 +101,12 @@ class Serialization:
         """
         Dumps an object to dictionary structure
         """
-        dump = jsons.dump(model, strip_privates=True)
-        if isinstance(dump, dict) or isinstance(dump, List):
-            return dump
 
-        raise ValueError("Unable to convert object to dictionary")
+        dump = Serialization.to_dict(
+            instance=model, serialize_fn=lambda x: x, include_none=True
+        )
+
+        return dump
 
     @staticmethod
     def map(source: object, target: T, coerce: bool = True) -> T | None:
@@ -185,3 +227,103 @@ class Serialization:
                 "This procedure will update the property from False to True while serializing, "
                 "then back to False once serialization is complete. "
             ) from e
+
+    @staticmethod
+    def to_dict(
+        instance: SerializableModel,
+        serialize_fn,
+        include_none: bool = True,
+    ) -> Dict[str, Any]:
+        """To Dict / Dictionary"""
+
+        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, SerializableModel):
+                return serialize_fn(
+                    Serialization.to_dict(
+                        instance=value,
+                        serialize_fn=lambda x: x,
+                        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(
+                    Serialization.to_dict(
+                        value,
+                        serialize_fn,
+                        include_none=include_none,
+                    )
+                )
+
+        instance_dict = Serialization._add_properties(
+            instance, serialize_value, include_none=include_none
+        )
+
+        return instance_dict
+
+    @staticmethod
+    def _add_properties(
+        instance: SerializableModel,
+        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

boto3_assist-0.6.0/src/boto3_assist/version.py

@@ -0,0 +1 @@
+__version__ = '0.6.0'

{boto3_assist-0.5.1 → boto3_assist-0.6.0}/tests/models/serializable_model_test.py

@@ -28,13 +28,11 @@ class TestSerializableModel(unittest.TestCase):
             "active": True,
         }
 
-        self.target_object = ExampleModel()
-
     def test_map_valid_data(self):
         """
         Test mapping a valid dictionary to an object instance.
         """
-        result = ExampleModel.map(self.source_dict, self.target_object)
+        result = ExampleModel().map(self.source_dict)
 
         self.assertEqual(result.name, "John Doe")
         self.assertEqual(result.age, 30)
@@ -45,7 +43,7 @@ class TestSerializableModel(unittest.TestCase):
         Test mapping a dictionary with partial data.
         """
         partial_dict = {"name": "Jane Doe"}
-        result = ExampleModel.map(partial_dict, self.target_object)
+        result = ExampleModel().map(partial_dict)
 
         self.assertEqual(result.name, "Jane Doe")
         self.assertEqual(result.age, 0)  # Default value
@@ -56,7 +54,7 @@ class TestSerializableModel(unittest.TestCase):
         Test mapping an empty dictionary.
         """
         empty_dict = {}
-        result = ExampleModel.map(empty_dict, self.target_object)
+        result = ExampleModel().map(empty_dict)
 
         self.assertEqual(result.name, "")  # Default value
         self.assertEqual(result.age, 0)  # Default value
@@ -69,7 +67,7 @@ class TestSerializableModel(unittest.TestCase):
         invalid_dict = {"name": 123, "age": "thirty", "active": "yes"}
 
         with self.assertRaises(ValueError):
-            ExampleModel.map(invalid_dict, self.target_object, coerce=False)
+            ExampleModel().map(invalid_dict, coerce=False)
 
     def test_map_invalid_data_coerce_with_failure(self):
         """
@@ -77,7 +75,7 @@ class TestSerializableModel(unittest.TestCase):
         """
         invalid_dict = {"name": 123, "age": "thirty", "active": "yes"}
 
-        result = ExampleModel.map(invalid_dict, self.target_object)
+        result = ExampleModel().map(invalid_dict)
 
         self.assertEqual(result.name, "123")
         # currently we're allowing this to happen
@@ -90,24 +88,51 @@ class TestSerializableModel(unittest.TestCase):
         """
         invalid_dict = {"name": 123, "age": 30, "active": "yes"}
 
-        result = ExampleModel.map(invalid_dict, self.target_object)
+        result = ExampleModel().map(invalid_dict)
 
         self.assertEqual(result.name, "123")
         self.assertEqual(result.age, 30)
         self.assertEqual(result.active, True)
 
+    def test_map_mix_limited_fields(self):
+        """
+        Test mapping a dictionary with invalid data types.
+        """
+        model: ExampleModel = ExampleModel(name="Fred", age=25, active=True)
+        invalid_dict = {"age": 30}
+
+        result = model.map(invalid_dict)
+
+        self.assertEqual(result.name, "Fred")
+        self.assertEqual(result.age, 30)
+        self.assertEqual(result.active, True)
+
     def test_map_non_dict_source(self):
         """
         Test mapping from a non-dictionary source object.
         """
         source_object = ExampleModel(name="Alice", age=25, active=True)
 
-        result = ExampleModel.map(source_object, self.target_object)
+        result = ExampleModel().map(source_object)
 
         self.assertEqual(result.name, "Alice")
         self.assertEqual(result.age, 25)
         self.assertEqual(result.active, True)
 
+    def test_to_dictionary(self):
+        """
+        Test converting an object instance to a dictionary.
+        """
+        model = ExampleModel(name="Bob", age=35, active=False)
+
+        result = model.to_dictionary()
+
+        self.assertIsInstance(result, dict)
+        self.assertEqual(len(result), 3)
+        self.assertEqual(result.get("name"), "Bob")
+        self.assertEqual(result.get("age"), 35)
+        self.assertEqual(result.get("active"), False)
+
 
 if __name__ == "__main__":
     unittest.main()

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

@@ -1,30 +0,0 @@
-"""
-Geek Cafe, LLC
-Maintainers: Eric Wilson
-MIT License.  See Project Root for the license information.
-"""
-
-from __future__ import annotations
-from typing import TypeVar
-from boto3_assist.utilities.serialization_utility import Serialization
-
-
-class SerializableModel:
-    """Library to Serialize object to a DynamoDB Format"""
-
-    T = TypeVar("T", bound="SerializableModel")
-
-    @staticmethod
-    def map(source: dict | object, target: T, coerce: bool = True) -> T:
-        """
-        Map the source dictionary to the target object.
-
-        Args:
-        - source: The dictionary to map from.
-        - target: The object to map to.
-        """
-        mapped = Serialization.map(source, target, coerce=coerce)
-        if mapped is None:
-            raise ValueError("Unable to map source to target")
-
-        return mapped

boto3_assist-0.5.1/src/boto3_assist/version.py

@@ -1 +0,0 @@
-__version__ = '0.5.1'