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

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

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

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

{boto3_assist-0.5.0 → boto3_assist-0.5.1}/src/boto3_assist/cognito/user.py

@@ -1,7 +1,14 @@
+"""
+Geek Cafe, LLC
+Maintainers: Eric Wilson
+MIT License.  See Project Root for the license information.
+"""
+
 from typing import Optional
+from boto3_assist.models.serializable_model import SerializableModel
 
 
-class CognitoUser:
+class CognitoUser(SerializableModel):
     """A generic way to represent a cognito user"""
 
     def __init__(

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

@@ -0,0 +1,30 @@
+"""
+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.0 → boto3_assist-0.5.1}/src/boto3_assist/utilities/serialization_utility.py

@@ -5,11 +5,11 @@ from decimal import Decimal
 from typing import Dict, List, TypeVar
 import json
 import jsons
-from aws_lambda_powertools import Logger, Tracer
+from aws_lambda_powertools import Logger
 
 T = TypeVar("T")
 
-tracer = Tracer()
+
 logger = Logger()
 
 
@@ -67,7 +67,7 @@ class Serialization:
         raise ValueError("Unable to convert object to dictionary")
 
     @staticmethod
-    def map(source: object, target: T) -> T | None:
+    def map(source: object, target: T, coerce: bool = True) -> T | None:
         """Map an object from one object to another"""
         source_dict: dict | object
         if isinstance(source, dict):
@@ -76,12 +76,26 @@ class Serialization:
             source_dict = Serialization.convert_object_to_dict(source)
             if not isinstance(source_dict, dict):
                 return None
-        return Serialization.load_properties(source_dict, target=target)
+        return Serialization.load_properties(
+            source=source_dict, target=target, coerce=coerce
+        )
 
     @staticmethod
-    def load_properties(source: dict, target: T) -> T | None:
+    def load_properties(
+        source: dict,
+        target: T,
+        coerce: bool = True,
+    ) -> T | None:
         """
-        Converts a source to an object
+        Converts a source dictionary to a target object.
+
+        Args:
+            source (dict): The source dictionary containing properties.
+            target (T): The target object to populate.
+            coerce (bool): If True, attempts to convert values to the target attribute types. If False, raises an error for type mismatches.
+
+        Returns:
+            T | None: The populated target object, or None if an error occurred.
         """
         # Ensure target is an instance of the class
         if isinstance(target, type):
@@ -95,28 +109,56 @@ class Serialization:
             setattr(target, "__actively_serializing_data__", True)
 
         for key, value in source.items():
-            if Serialization.has_attribute(target, key):  # hasattr(target, key):
+            if Serialization.has_attribute(target, key):
                 attr = getattr(target, key)
-                if isinstance(attr, (int, float, str, bool, type(None))):
-                    try:
+                expected_type = type(attr)
+
+                try:
+                    if isinstance(attr, (int, float, str, bool)):
+                        if not isinstance(value, expected_type):
+                            if coerce:
+                                # Attempt to coerce the value to the expected type
+                                try:
+                                    value = expected_type(value)
+                                except ValueError as e:
+                                    logger.warning(
+                                        f"Warning coercing attribute {key} with value {value}: {e}"
+                                    )
+                                    # TODO: should we set numbers to 0 or a NaN or raise an error
+
+                                    setattr(target, key, value)
+                                    # raise ValueError(  # pylint: disable=w0707
+                                    #     f"Type mismatch for attribute {key}. Expected {expected_type}, got {type(value)}."
+                                    # )
+                            else:
+                                raise ValueError(
+                                    f"Type mismatch for attribute {key}. Expected {expected_type}, got {type(value)}."
+                                )
+                        setattr(target, key, value)
+                    elif isinstance(attr, type(None)):
+                        setattr(target, key, value)
+                    elif isinstance(attr, list) and isinstance(value, list):
+                        attr.clear()
+                        attr.extend(value)
+                    elif isinstance(attr, dict) and isinstance(value, dict):
+                        Serialization.load_properties(value, attr, coerce=coerce)
+                    elif hasattr(attr, "__dict__") and isinstance(value, dict):
+                        Serialization.load_properties(value, attr, coerce=coerce)
+                    else:
                         setattr(target, key, value)
-                    except Exception as e:  # pylint: disable=w0718
-                        logger.error(
-                            f"Error setting attribute {key} with value {value}: {e}. "
-                            "This usually occurs on properties that don't have setters. "
-                            "You can add a setter (even with a pass action) for this property, "
-                            "decorate it with the @exclude_from_serialization "
-                            "or ignore this error. "
-                        )
-                elif isinstance(attr, list) and isinstance(value, list):
-                    attr.clear()
-                    attr.extend(value)
-                elif isinstance(attr, dict) and isinstance(value, dict):
-                    Serialization.load_properties(value, attr)
-                elif hasattr(attr, "__dict__") and isinstance(value, dict):
-                    Serialization.load_properties(value, attr)
-                else:
-                    setattr(target, key, value)
+                except ValueError as e:
+                    logger.error(
+                        f"Error setting attribute {key} with value {value}: {e}"
+                    )
+                    raise
+                except Exception as e:  # pylint: disable=w0718
+                    logger.error(
+                        f"Error setting attribute {key} with value {value}: {e}. "
+                        "This usually occurs on properties that don't have setters. "
+                        "You can add a setter (even with a pass action) for this property, "
+                        "decorate it with the @exclude_from_serialization "
+                        "or ignore this error. "
+                    )
 
         if hasattr(target, "__actively_serializing_data__"):
             setattr(target, "__actively_serializing_data__", False)

boto3_assist-0.5.1/src/boto3_assist/version.py

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

boto3_assist-0.5.1/tests/models/serializable_model_test.py

@@ -0,0 +1,113 @@
+"""
+Geek Cafe, LLC
+Maintainers: Eric Wilson
+MIT License.  See Project Root for the license information.
+"""
+
+import unittest
+from typing import Dict
+from boto3_assist.models.serializable_model import SerializableModel
+
+
+class ExampleModel(SerializableModel):
+    """A model that inherits the serializable"""
+
+    def __init__(self, name: str = "", age: int = 0, active: bool = False):
+        self.name = name
+        self.age = age
+        self.active = active
+
+
+class TestSerializableModel(unittest.TestCase):
+    """Testing Serialzing Models"""
+
+    def setUp(self) -> None:
+        self.source_dict: Dict[str, any] = {
+            "name": "John Doe",
+            "age": 30,
+            "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)
+
+        self.assertEqual(result.name, "John Doe")
+        self.assertEqual(result.age, 30)
+        self.assertEqual(result.active, True)
+
+    def test_map_partial_data(self):
+        """
+        Test mapping a dictionary with partial data.
+        """
+        partial_dict = {"name": "Jane Doe"}
+        result = ExampleModel.map(partial_dict, self.target_object)
+
+        self.assertEqual(result.name, "Jane Doe")
+        self.assertEqual(result.age, 0)  # Default value
+        self.assertEqual(result.active, False)  # Default value
+
+    def test_map_empty_data(self):
+        """
+        Test mapping an empty dictionary.
+        """
+        empty_dict = {}
+        result = ExampleModel.map(empty_dict, self.target_object)
+
+        self.assertEqual(result.name, "")  # Default value
+        self.assertEqual(result.age, 0)  # Default value
+        self.assertEqual(result.active, False)  # Default value
+
+    def test_map_invalid_data(self):
+        """
+        Test mapping a dictionary with invalid data types.
+        """
+        invalid_dict = {"name": 123, "age": "thirty", "active": "yes"}
+
+        with self.assertRaises(ValueError):
+            ExampleModel.map(invalid_dict, self.target_object, coerce=False)
+
+    def test_map_invalid_data_coerce_with_failure(self):
+        """
+        Test mapping a dictionary with invalid data types.
+        """
+        invalid_dict = {"name": 123, "age": "thirty", "active": "yes"}
+
+        result = ExampleModel.map(invalid_dict, self.target_object)
+
+        self.assertEqual(result.name, "123")
+        # currently we're allowing this to happen
+        self.assertEqual(result.age, "thirty")
+        self.assertEqual(result.active, True)
+
+    def test_map_invalid_data_coerce(self):
+        """
+        Test mapping a dictionary with invalid data types.
+        """
+        invalid_dict = {"name": 123, "age": 30, "active": "yes"}
+
+        result = ExampleModel.map(invalid_dict, self.target_object)
+
+        self.assertEqual(result.name, "123")
+        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)
+
+        self.assertEqual(result.name, "Alice")
+        self.assertEqual(result.age, 25)
+        self.assertEqual(result.active, True)
+
+
+if __name__ == "__main__":
+    unittest.main()

boto3_assist-0.5.0/src/boto3_assist/version.py

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