boto3-assist 0.1.8__tar.gz → 0.1.10__tar.gz

{boto3_assist-0.1.8 → boto3_assist-0.1.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: boto3_assist
-Version: 0.1.8
+Version: 0.1.10
 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.1.8 → boto3_assist-0.1.10}/pyproject.toml

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

{boto3_assist-0.1.8 → boto3_assist-0.1.10}/src/boto3_assist/dynamodb/dynamodb_model_base.py

@@ -80,6 +80,10 @@ class DynamoDBModelBase:
         """Gets the auto generate projections"""
         return self.__auto_generate_projections
 
+    @auto_generate_projections.setter
+    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
@@ -153,21 +157,25 @@ class DynamoDBModelBase:
             self, include_indexes=include_indexes
         )
 
-    def to_resource_dictionary(self, include_indexes: bool = True):
+    def to_resource_dictionary(
+        self, include_indexes: bool = True, include_none: bool = False
+    ):
         """
         Convert the instance to a dictionary suitable for DynamoDB resource.
         """
         return DynamoDBSerializer.to_resource_dictionary(
-            self, include_indexes=include_indexes
+            self, include_indexes=include_indexes, include_none=include_none
         )
 
-    def to_dictionary(self):
+    def to_dictionary(self, include_none: bool = True):
         """
         Convert the instance to a dictionary without an indexes/keys.
         Usefull for turning an object into a dictionary for serialization.
         This is the same as to_resource_dictionary(include_indexes=False)
         """
-        return DynamoDBSerializer.to_resource_dictionary(self, include_indexes=False)
+        return DynamoDBSerializer.to_resource_dictionary(
+            self, include_indexes=False, include_none=include_none
+        )
 
     def get_key(self, index_name: str) -> DynamoDBIndex:
         """Get the index name and key"""
@@ -232,7 +240,9 @@ class DynamoDBSerializer:
 
     @staticmethod
     def to_resource_dictionary(
-        instance: DynamoDBModelBase, include_indexes: bool = True
+        instance: DynamoDBModelBase,
+        include_indexes: bool = True,
+        include_none: bool = False,
     ):
         """
         Convert a Python class instance to a dictionary suitable for DynamoDB resource.
@@ -244,12 +254,18 @@ class DynamoDBSerializer:
         - dict: A dictionary representation of the class instance suitable for DynamoDB resource.
         """
         return DynamoDBSerializer._serialize(
-            instance, lambda x: x, include_indexes=include_indexes
+            instance,
+            lambda x: x,
+            include_indexes=include_indexes,
+            include_none=include_none,
         )
 
     @staticmethod
     def _serialize(
-        instance: DynamoDBModelBase, serialize_fn, include_indexes: bool = True
+        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."""
@@ -259,7 +275,11 @@ class DynamoDBSerializer:
             """Serialize the value using the provided function."""
 
             if isinstance(value, DynamoDBModelBase):
-                return serialize_fn(value.to_resource_dictionary(False))
+                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):
@@ -278,23 +298,36 @@ class DynamoDBSerializer:
             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))
+                return serialize_fn(
+                    DynamoDBSerializer._serialize(
+                        value,
+                        serialize_fn,
+                        include_indexes=include_indexes,
+                        include_none=include_none,
+                    )
+                )
 
-        instance_dict = DynamoDBSerializer._add_properties(instance, serialize_value)
+        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
 
     @staticmethod
-    def _add_properties(instance: DynamoDBModelBase, serialize_value) -> dict:
+    def _add_properties(
+        instance: DynamoDBModelBase,
+        serialize_value,
+        include_none: bool = True,
+    ) -> dict:
         instance_dict = {}
 
         # Add instance variables
         for attr, value in instance.__dict__.items():
             # don't get the private properties
             if not str(attr).startswith("_"):
-                if value is not None:
+                if value is not None or include_none:
                     instance_dict[attr] = serialize_value(value)
 
         # Add properties
@@ -316,7 +349,7 @@ class DynamoDBSerializer:
                 # don't get the private properties
                 if not str(name).startswith("_"):
                     value = getattr(instance, name)
-                    if value is not None:
+                    if value is not None or include_none:
                         instance_dict[name] = serialize_value(value)
 
         return instance_dict

boto3_assist-0.1.10/src/boto3_assist/version.py

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

{boto3_assist-0.1.8 → boto3_assist-0.1.10}/tests/dynamodb/dynamodb_model_projections_test.py

@@ -80,3 +80,30 @@ class DynamoDBModeProjectionlUnitTest(unittest.TestCase):
 
         attribute_names = model.projection_expression_attribute_names
         self.assertIsNone(attribute_names)
+
+    def test_user_model_and_nulls(self):
+        model: User = User()
+        model.first_name = "John"
+
+        expressions = model.projection_expression
+        self.assertIsInstance(expressions, str)
+
+        self.assertIn("id", expressions)
+
+    def test_user_limited_projections(self):
+        model: User = User()
+        model.first_name = "John"
+
+        model.projection_expression = "id"
+        model.projection_expression_attribute_names = None
+        model.auto_generate_projections = False
+        expressions = model.projection_expression
+        attributes = model.projection_expression_attribute_names
+        self.assertIsInstance(expressions, str)
+
+        self.assertIn("id", expressions)
+        self.assertNotIn("first_name", expressions)
+        self.assertNotIn("age", expressions)
+        self.assertNotIn("email", expressions)
+        self.assertNotIn("status", expressions)
+        self.assertIsNone(attributes)

boto3_assist-0.1.8/src/boto3_assist/version.py

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