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

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

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

{boto3_assist-0.6.0 → 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.6.0 → boto3_assist-0.6.1}/PKG-INFO

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

@@ -7,7 +7,7 @@ packages = ["src/boto3_assist"]
 
 [project]
 name = "boto3_assist"
-version = "0.6.0"
+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.6.0 → boto3_assist-0.6.1}/src/boto3_assist/models/serializable_model.py

@@ -5,5 +5,5 @@ 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
+
+from boto3_assist.utilities.serialization_utility import SerializableModel  # noqa: F401 # pylint: disable=unused-import

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

@@ -1,16 +1,15 @@
 """Serialization Utility"""
 
-from datetime import datetime
-from decimal import Decimal
-from typing import Dict, List, TypeVar, Any
-import json
-import jsons
 import datetime as dt
 import decimal
 import inspect
+import json
 import uuid
-from aws_lambda_powertools import Logger
+from datetime import datetime
+from decimal import Decimal
+from typing import Any, Dict, List, TypeVar
 
+from aws_lambda_powertools import Logger
 
 T = TypeVar("T")
 
@@ -53,6 +52,15 @@ class SerializableModel:
             instance=self, serialize_fn=lambda x: x, include_none=True
         )
 
+    def to_wide_dictionary(self) -> Dict:
+        """
+        Dumps an object to dictionary structure
+        """
+
+        dump = Serialization.to_wide_dictionary(model=self)
+
+        return dump
+
 
 class JsonEncoder(json.JSONEncoder):
     """
@@ -108,6 +116,32 @@ class Serialization:
 
         return dump
 
+    @staticmethod
+    def to_wide_dictionary(model: object) -> Dict:
+        """
+        Dumps an object to dictionary structure
+        """
+
+        dump = Serialization.to_dict(
+            instance=model, serialize_fn=lambda x: x, include_none=True
+        )
+
+        # have a dictionary now let's flatten out
+        flat_dict = {}
+        for key, value in dump.items():
+            if isinstance(value, dict):
+                for sub_key, sub_value in value.items():
+                    flat_dict[f"{key}_{sub_key}"] = sub_value
+            elif isinstance(value, list):
+                for i, sub_value in enumerate(value):
+                    sub_dict = Serialization.to_wide_dictionary(sub_value)
+                    for sub_key, sub_value in sub_dict.items():
+                        flat_dict[f"{key}_{i}_{sub_key}"] = sub_value
+            else:
+                flat_dict[key] = value
+
+        return flat_dict
+
     @staticmethod
     def map(source: object, target: T, coerce: bool = True) -> T | None:
         """Map an object from one object to another"""
@@ -118,12 +152,92 @@ class Serialization:
             source_dict = Serialization.convert_object_to_dict(source)
             if not isinstance(source_dict, dict):
                 return None
-        return Serialization.load_properties(
+        return Serialization._load_properties(
             source=source_dict, target=target, coerce=coerce
         )
 
     @staticmethod
-    def load_properties(
+    def to_wide_dictionary_list(
+        data: Dict[str, Any] | List[Dict[str, Any]],
+        remove_collisions: bool = True,
+        raise_error_on_collision: bool = False,
+    ) -> List[Dict[str, Any]]:
+        """
+        Converts a dictionary or list of dictionaries to a list of dictionaries.
+
+        :param data: Dictionary or list of dictionaries to be converted
+        :param remove_collisions: If True, removes duplicate keys from the dictionaries
+        :return: List of dictionaries
+        """
+
+        collisions = []
+
+        def recursive_flatten(prefix, obj):
+            """
+            Recursively flattens a JSON object.
+
+            :param prefix: Current key prefix
+            :param obj: Object to flatten
+            :return: List of flattened dictionaries
+            """
+            if isinstance(obj, list):
+                result = []
+                for _, item in enumerate(obj):
+                    x = recursive_flatten("", item)
+                    result.extend(x)
+                return result
+            elif isinstance(obj, dict):
+                result = [{}]
+                for key, value in obj.items():
+                    sub_result = recursive_flatten(
+                        f"{prefix}_{key}" if prefix else key, value
+                    )
+                    new_result = []
+                    for entry in result:
+                        for sub_entry in sub_result:
+                            # remove any collisions
+
+                            for k in entry:
+                                if k in sub_entry:
+                                    if k not in collisions:
+                                        logger.debug(f"Collision detected: {k}")
+                                        collisions.append(k)
+                            merged = entry.copy()
+                            merged.update(sub_entry)
+                            new_result.append(merged)
+                    result = new_result
+                return result
+            else:
+                return [{prefix: obj}] if prefix else []
+
+        results = recursive_flatten("", data)
+        if remove_collisions:
+            results = Serialization.remove_collisions(results, collisions)
+
+        if raise_error_on_collision and len(collisions) > 0:
+            raise ValueError(f"Duplicate keys detected: {collisions}")
+
+        return results
+
+    @staticmethod
+    def remove_collisions(
+        data: List[Dict[str, Any]], collisions: List[str]
+    ) -> List[Dict[str, Any]]:
+        """
+        Removes collisions from a list of dictionaries.
+
+        :param data: List of dictionaries
+        :param collisions: List of collision keys
+        :return: List of dictionaries with collisions removed
+        """
+        for c in collisions:
+            for r in data:
+                if c in r:
+                    del r[c]
+        return data
+
+    @staticmethod
+    def _load_properties(
         source: dict,
         target: T,
         coerce: bool = True,
@@ -183,9 +297,9 @@ class Serialization:
                         attr.clear()
                         attr.extend(value)
                     elif isinstance(attr, dict) and isinstance(value, dict):
-                        Serialization.load_properties(value, attr, coerce=coerce)
+                        Serialization._load_properties(value, attr, coerce=coerce)
                     elif hasattr(attr, "__dict__") and isinstance(value, dict):
-                        Serialization.load_properties(value, attr, coerce=coerce)
+                        Serialization._load_properties(value, attr, coerce=coerce)
                     else:
                         setattr(target, key, value)
                 except ValueError as e:
@@ -230,12 +344,18 @@ class Serialization:
 
     @staticmethod
     def to_dict(
-        instance: SerializableModel,
+        instance: SerializableModel | dict,
         serialize_fn,
         include_none: bool = True,
     ) -> Dict[str, Any]:
         """To Dict / Dictionary"""
 
+        if instance is None:
+            return {}
+
+        if isinstance(instance, dict):
+            return instance
+
         def is_primitive(value):
             """Check if the value is a primitive data type."""
             return isinstance(value, (str, int, bool, type(None)))

boto3_assist-0.6.1/src/boto3_assist/version.py

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

{boto3_assist-0.6.0/tests/utilities → boto3_assist-0.6.1/tests/__top}/__init__.py

@@ -9,8 +9,11 @@ import sys
 from pathlib import Path
 
 ## needed for discovery based top level execution
+print("👋 init test paths for __top")
 root_directory = Path(__file__).resolve().parent.parent.parent
 src_directory = os.path.join(root_directory, "src")
 
 sys.path.insert(0, src_directory)
-print(sys.path)
+print("")
+for p in sys.path:
+    print(f"👉 {p}")

{boto3_assist-0.6.0/tests/dynamodb/models → boto3_assist-0.6.1/tests/dynamodb/dbmodels}/cms/page.py

@@ -7,7 +7,7 @@ MIT License.  See Project Root for the license information.
 from typing import List, Dict, Any
 import datetime as dt
 from boto3_assist.dynamodb.dynamodb_index import DynamoDBIndex, DynamoDBKey
-from tests.dynamodb.models.cms.base import BaseCMSDBModel
+from tests.dynamodb.dbmodels.cms.base import BaseCMSDBModel
 
 
 class Page(BaseCMSDBModel):

{boto3_assist-0.6.0 → boto3_assist-0.6.1}/tests/dynamodb/dynamodb_model_base_test.py

@@ -5,12 +5,11 @@ MIT License.  See Project Root for the license information.
 """
 
 import unittest
-from typing import List, Dict
-
+from typing import Dict, List
 
 from boto3_assist.dynamodb.dynamodb_index import DynamoDBIndex
-from src.boto3_assist.dynamodb.dynamodb_key import DynamoDBKey
-from tests.dynamodb.models.user_model import User
+from boto3_assist.dynamodb.dynamodb_key import DynamoDBKey
+from tests.dynamodb.dbmodels.user_model import User
 
 
 class DynamoDBModelUnitTest(unittest.TestCase):

{boto3_assist-0.6.0 → boto3_assist-0.6.1}/tests/dynamodb/dynamodb_model_projections_test.py

@@ -7,8 +7,8 @@ MIT License.  See Project Root for the license information.
 import unittest
 
 
-from tests.dynamodb.models.user_model import User
-from tests.dynamodb.models.simple_model import Simple
+from tests.dynamodb.dbmodels.user_model import User
+from tests.dynamodb.dbmodels.simple_model import Simple
 
 
 class DynamoDBModeProjectionlUnitTest(unittest.TestCase):

{boto3_assist-0.6.0 → boto3_assist-0.6.1}/tests/dynamodb/dynamodb_model_serializtion_test.py

@@ -7,8 +7,8 @@ MIT License.  See Project Root for the license information.
 import unittest
 
 
-from tests.dynamodb.models.user_model import User
-from tests.dynamodb.models.user_required_fields_model import User as User2
+from tests.dynamodb.dbmodels.user_model import User
+from tests.dynamodb.dbmodels.user_required_fields_model import User as User2
 
 
 class DynamoDBModelSerializationUnitTest(unittest.TestCase):

{boto3_assist-0.6.0 → boto3_assist-0.6.1}/tests/dynamodb/dynamodb_moto_sorting_test.py

@@ -4,17 +4,15 @@ Maintainers: Eric Wilson
 MIT License.  See Project Root for the license information.
 """
 
-import os
 import unittest
-import moto
 from typing import List
 
-
+import moto
 from mypy_boto3_dynamodb import DynamoDBClient
 
-from dynamodb.models.cms.page import Page
-from boto3_assist.environment_services.environment_loader import EnvironmentLoader
 from boto3_assist.dynamodb.dynamodb import DynamoDB
+from boto3_assist.environment_services.environment_loader import EnvironmentLoader
+from tests.dynamodb.dbmodels.cms.page import Page
 
 
 @moto.mock_aws

boto3_assist-0.6.1/tests/models/serializable_model_wide_test.py

@@ -0,0 +1,246 @@
+"""
+Geek Cafe, LLC
+Maintainers: Eric Wilson
+MIT License.  See Project Root for the license information.
+"""
+
+import unittest
+
+from boto3_assist.models.serializable_model import SerializableModel
+from boto3_assist.utilities.serialization_utility import Serialization
+
+
+class Address(SerializableModel):
+    """A model that inherits the serializable"""
+
+    def __init__(
+        self,
+        *,
+        id: str | None = None,  # pylint: disable=redefined-builtin
+        street: str | None = None,
+        city: str | None = None,
+        state: str | None = None,
+        zip: str | None = None,  # pylint: disable=redefined-builtin
+    ):
+        self.id: str | None = id
+        self.street: str | None = street
+        self.city: str | None = city
+        self.state: str | None = state
+        self.zip: str | None = zip
+
+
+class User(SerializableModel):
+    """A model that inherits the serializable"""
+
+    def __init__(self):
+        self.__id: str | None = None
+        self.first_name: str = ""
+        self.last_name: str = ""
+        self.addresses: list[Address] = []
+
+    @property
+    def id(self) -> str:
+        """The id of the order"""
+        return self.__id
+
+    @id.setter
+    def id(self, value: str) -> None:
+        self.__id = value
+
+
+class TestSerializableModel(unittest.TestCase):
+    """Testing Serialzing Models"""
+
+    def setUp(self) -> None:
+        pass
+
+    def test_map_valid_data(self):
+        """
+        Test mapping a valid dictionary to an object instance.
+        """
+        user: User = User()
+        user.id = "1"
+        user.first_name = "John"
+        user.last_name = "Smith"
+        for i in range(3):
+            user.addresses.append(
+                Address(
+                    id=str(i),
+                    street=f"10{i} S. Main St.",
+                    city="Anytown",
+                    state="AnyWhere",
+                    zip="00001",
+                )
+            )
+
+        flat = user.to_wide_dictionary()
+
+        self.assertIsNotNone(flat)
+        self.assertEqual(flat["id"], "1")
+        self.assertEqual(flat["first_name"], "John")
+        self.assertEqual(flat["last_name"], "Smith")
+        self.assertEqual(flat["addresses_0_id"], "0")
+        self.assertEqual(flat["addresses_0_street"], "100 S. Main St.")
+        self.assertEqual(flat["addresses_0_city"], "Anytown")
+        self.assertEqual(flat["addresses_0_state"], "AnyWhere")
+        self.assertEqual(flat["addresses_0_zip"], "00001")
+
+    def test_dict_wide(self):
+        model = {
+            "id": "1",
+            "first_name": "John",
+            "last_name": "Smith",
+            "addresses": [
+                {
+                    "id": "0",
+                    "street": "100 S. Main St.",
+                    "city": "Anytown",
+                    "state": "AnyWhere",
+                    "zip": "00001",
+                },
+                {
+                    "id": "1",
+                    "street": "101 S. Main St.",
+                    "city": "Anytown",
+                    "state": "AnyWhere",
+                    "zip": "00001",
+                },
+            ],
+        }
+
+        flat = Serialization.to_wide_dictionary(model)
+
+        self.assertIsNotNone(flat)
+        self.assertEqual(flat["id"], "1")
+        self.assertEqual(flat["first_name"], "John")
+        self.assertEqual(flat["last_name"], "Smith")
+        self.assertEqual(flat["addresses_0_id"], "0")
+        self.assertEqual(flat["addresses_0_street"], "100 S. Main St.")
+        self.assertEqual(flat["addresses_0_city"], "Anytown")
+        self.assertEqual(flat["addresses_0_state"], "AnyWhere")
+        self.assertEqual(flat["addresses_0_zip"], "00001")
+
+    def test_dict_multi_level_array(self):
+        model = {
+            "id": "1",
+            "level_one_array": [
+                {
+                    "id": "1",
+                    "level_two_array": [
+                        {
+                            "id": "1",
+                            "level_three_array": [
+                                {
+                                    "id": "1",
+                                }
+                            ],
+                        }
+                    ],
+                }
+            ],
+        }
+
+        flat = Serialization.to_wide_dictionary(model)
+
+        self.assertIsNotNone(flat)
+        self.assertEqual(flat["id"], "1")
+        self.assertEqual(flat["level_one_array_0_id"], "1")
+        self.assertEqual(flat["level_one_array_0_level_two_array_0_id"], "1")
+        self.assertEqual(
+            flat["level_one_array_0_level_two_array_0_level_three_array_0_id"], "1"
+        )
+
+    def test_dict_wide_list_happy_path(self):
+        model = {
+            "first_name": "John",
+            "last_name": "Smith",
+            "addresses": [
+                {
+                    "street": "100 S. Main St.",
+                    "city": "Anytown",
+                    "state": "AnyWhere",
+                    "zip": "00001",
+                },
+                {
+                    "street": "101 S. Main St.",
+                    "city": "Anytown",
+                    "state": "AnyWhere",
+                    "zip": "00001",
+                },
+            ],
+        }
+
+        expected_results = [
+            {
+                "first_name": "John",
+                "last_name": "Smith",
+                "street": "100 S. Main St.",
+                "city": "Anytown",
+                "state": "AnyWhere",
+                "zip": "00001",
+            },
+            {
+                "first_name": "John",
+                "last_name": "Smith",
+                "street": "101 S. Main St.",
+                "city": "Anytown",
+                "state": "AnyWhere",
+                "zip": "00001",
+            },
+        ]
+
+        flat = Serialization.to_wide_dictionary_list(model)
+
+        self.assertIsNotNone(flat)
+        self.assertEqual(flat, expected_results)
+
+    def test_dict_wide_list_duplicate_keys(self):
+        model = {
+            "id": "1",
+            "first_name": "John",
+            "last_name": "Smith",
+            "addresses": [
+                {
+                    "id": "a",
+                    "street": "100 S. Main St.",
+                    "city": "Anytown",
+                    "state": "AnyWhere",
+                    "zip": "00001",
+                },
+                {
+                    "id": "b",
+                    "street": "101 S. Main St.",
+                    "city": "Anytown",
+                    "state": "AnyWhere",
+                    "zip": "00001",
+                },
+            ],
+        }
+
+        expected_results = [
+            {
+                "first_name": "John",
+                "last_name": "Smith",
+                "street": "100 S. Main St.",
+                "city": "Anytown",
+                "state": "AnyWhere",
+                "zip": "00001",
+            },
+            {
+                "first_name": "John",
+                "last_name": "Smith",
+                "street": "101 S. Main St.",
+                "city": "Anytown",
+                "state": "AnyWhere",
+                "zip": "00001",
+            },
+        ]
+
+        flat = Serialization.to_wide_dictionary_list(model)
+
+        self.assertIsNotNone(flat)
+        self.assertEqual(flat, expected_results)
+
+
+if __name__ == "__main__":
+    unittest.main()

boto3_assist-0.6.0/src/boto3_assist/version.py

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

boto3_assist-0.6.0/tests/__top/__init__.py

@@ -1,16 +0,0 @@
-"""
-Geek Cafe, LLC
-Maintainers: Eric Wilson
-MIT License.  See Project Root for the license information.
-"""
-
-import os
-import sys
-from pathlib import Path
-
-## needed for discovery based top level execution
-root_directory = Path(__file__).resolve().parent.parent.parent
-src_directory = os.path.join(root_directory, "src")
-
-sys.path.insert(0, src_directory)
-print(sys.path)