boto3-assist 0.5.2__py3-none-any.whl → 0.6.1__py3-none-any.whl

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/models/serializable_model.py

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

boto3_assist/utilities/serialization_utility.py

@@ -1,10 +1,14 @@
 """Serialization Utility"""
 
+import datetime as dt
+import decimal
+import inspect
+import json
+import uuid
 from datetime import datetime
 from decimal import Decimal
-from typing import Dict, List, TypeVar
-import json
-import jsons
+from typing import Any, Dict, List, TypeVar
+
 from aws_lambda_powertools import Logger
 
 T = TypeVar("T")
@@ -13,6 +17,51 @@ 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
+        )
+
+    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):
     """
     This class is used to serialize python generics which implement a __json_encode__ method
@@ -52,7 +101,7 @@ class JsonEncoder(json.JSONEncoder):
 
 class Serialization:
     """
-    Serliaztion Class
+    Serialization Class
     """
 
     @staticmethod
@@ -60,11 +109,38 @@ 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 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:
@@ -76,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,
@@ -141,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:
@@ -185,3 +341,109 @@ 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 | 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)))
+
+        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/version.py

@@ -1 +1 @@
-__version__ = '0.5.2'
+__version__ = '0.6.1'

{boto3_assist-0.5.2.dist-info → boto3_assist-0.6.1.dist-info}/METADATA

@@ -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.dist-info → boto3_assist-0.6.1.dist-info}/RECORD

@@ -3,7 +3,7 @@ boto3_assist/boto3session.py,sha256=Q9sByNC0r_aMQfHnIEnxtTaiCMUqikm8UeSTxV7-Np0,
 boto3_assist/connection.py,sha256=CNGkAIRyfrELoWrV0ziQBA3oHacNFuLL3i8faUPRiO0,3486
 boto3_assist/connection_tracker.py,sha256=bfImvNVX-0Lhb-ombOurWUpNLdI0qVDil-kokBdIFkY,4345
 boto3_assist/http_status_codes.py,sha256=G0zRSWenwavYKETvDF9tNVUXQz3Ae2gXdBETYbjvJe8,3284
-boto3_assist/version.py,sha256=pIxUWQG2brcif6SJXtn4CcMr6f5oY-6lwZ_FJEilJwQ,22
+boto3_assist/version.py,sha256=gd3s3RotD0_KL90Tua-YkOr60Jm2C2_wvlEhAT08068,22
 boto3_assist/aws_lambda/event_info.py,sha256=OkZ4WzuGaHEu_T8sB188KBgShAJhZpWASALKRGBOhMg,14648
 boto3_assist/cloudwatch/cloudwatch_connection.py,sha256=mnGWaLSQpHh5EeY7Ek_2o9JKHJxOELIYtQVMX1IaHn4,2480
 boto3_assist/cloudwatch/cloudwatch_connection_tracker.py,sha256=mzRtO1uHrcfJNh1XrGEiXdTqxwEP8d1RqJkraMNkgK0,410
@@ -22,7 +22,7 @@ boto3_assist/dynamodb/dynamodb_importer.py,sha256=nCKsyRQeMqDSf0Q5mQ_X_oVIg4PRnu
 boto3_assist/dynamodb/dynamodb_index.py,sha256=D0Lq121qk1cXeMetPeqnzvv6CXd0XfEygfdUXaljLG8,8551
 boto3_assist/dynamodb/dynamodb_iservice.py,sha256=O9Aj0PFEvcuk2vhARifWTFnUwcQW5EXzwZS478Hm-N0,796
 boto3_assist/dynamodb/dynamodb_key.py,sha256=YD7o1EUlwVBQ55p9YCTKqAUU_np4nqtLIHnmp-BeolM,1803
-boto3_assist/dynamodb/dynamodb_model_base.py,sha256=T7mqn_PXY4QY5KWWKjmBQTNl-vM3_B94kX4DlDw0DkI,15401
+boto3_assist/dynamodb/dynamodb_model_base.py,sha256=Jmy0GAblYqdLlVOT7H-1li50bacemeduocgNs75Yvt8,11910
 boto3_assist/dynamodb/dynamodb_model_base_interfaces.py,sha256=yT4zDRI8vP15WVOHnCvY3FsEy_QSIta5-bnUby70Xow,747
 boto3_assist/dynamodb/dynamodb_reindexer.py,sha256=bCj6KIU0fQOgjkkiq9yF51PFZZr4Y9Lu3-hPlmsPG0Y,6164
 boto3_assist/dynamodb/dynamodb_reserved_words.py,sha256=p0irNBSqGe4rd2FwWQqbRJWrNr4svdbWiyIXmz9lj4c,1937
@@ -34,7 +34,7 @@ boto3_assist/environment_services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeR
 boto3_assist/environment_services/environment_loader.py,sha256=zCA4mRdVWMLKzjDRvrJbhQfRVP4HAMGpuQFi07zzULk,3396
 boto3_assist/environment_services/environment_variables.py,sha256=4ccBKdPt6O7hcRT3zBHd8vqu8yQU8udmoD5RLAT3iMs,6801
 boto3_assist/errors/custom_exceptions.py,sha256=zC2V2Y4PUtKj3uLPn8mB-JessksKWJWvKM9kp1dmvt8,760
-boto3_assist/models/serializable_model.py,sha256=j77RJD3o5euqwWek2IpvqdG6quf5yvoY-_NMvYTOBaE,912
+boto3_assist/models/serializable_model.py,sha256=ZMrRJRvJWLY8PBSKK_nPCgYKv1qUxDPEVdcADKbIHsI,266
 boto3_assist/s3/s3.py,sha256=DFCJs5z1mMIT8nZfnqPyr_cvhi9-FePuYH--tzD7b5E,17104
 boto3_assist/s3/s3_connection.py,sha256=FI1AhZV4UbTXQRTb4TqL9mv88Gt018rPZVFBvLetVAw,2163
 boto3_assist/utilities/datetime_utility.py,sha256=dgAMB9VqakrYIPXlSoVQiLSsc_yhrJK4gMfJO9mX90w,11112
@@ -43,10 +43,10 @@ boto3_assist/utilities/file_operations.py,sha256=Zy8fu8fpuVNf7U9NimrLdy5FRF71XSI
 boto3_assist/utilities/http_utility.py,sha256=koFv7Va-8ng-47Nt1K2Sh7Ti95e62IYs9VMLlGh9Kt4,1173
 boto3_assist/utilities/logging_utility.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 boto3_assist/utilities/numbers_utility.py,sha256=KIiNkBSRbfNWvtXG5SdHp625LTiW12VtADUa4ZlWMFo,8709
-boto3_assist/utilities/serialization_utility.py,sha256=p9QQfc6EDOtD-mB6Ujhv-BRpDn3DCCG2z5VmXG1kmb0,7768
+boto3_assist/utilities/serialization_utility.py,sha256=KJhit0lI1lr8hhndW6UhKQSZD3c2RH555Ni7eP-e5Ms,16557
 boto3_assist/utilities/string_utility.py,sha256=sBY80aQO-fTRanlHryZFMQBxdo6OvLRvnZjZrQepHlI,9283
-boto3_assist-0.5.2.dist-info/METADATA,sha256=Pb5bNBGK2wy_4Pcw806qrDytmaOySGqKrd8LWVc6iEM,1728
-boto3_assist-0.5.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-boto3_assist-0.5.2.dist-info/licenses/LICENSE-EXPLAINED.txt,sha256=WFREvTpfTjPjDHpOLADxJpCKpIla3Ht87RUUGii4ODU,606
-boto3_assist-0.5.2.dist-info/licenses/LICENSE.txt,sha256=PXDhFWS5L5aOTkVhNvoitHKbAkgxqMI2uUPQyrnXGiI,1105
-boto3_assist-0.5.2.dist-info/RECORD,,
+boto3_assist-0.6.1.dist-info/METADATA,sha256=MVB3qF040hI48bRH8xhXXkyX9aewgYUUiGtUubi2l-0,1728
+boto3_assist-0.6.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+boto3_assist-0.6.1.dist-info/licenses/LICENSE-EXPLAINED.txt,sha256=WFREvTpfTjPjDHpOLADxJpCKpIla3Ht87RUUGii4ODU,606
+boto3_assist-0.6.1.dist-info/licenses/LICENSE.txt,sha256=PXDhFWS5L5aOTkVhNvoitHKbAkgxqMI2uUPQyrnXGiI,1105
+boto3_assist-0.6.1.dist-info/RECORD,,