boto3-assist 0.4.0__py3-none-any.whl → 0.5.1__py3-none-any.whl

boto3_assist/utilities/numbers_utility.py

@@ -0,0 +1,286 @@
+import math
+from typing import List, Optional
+from aws_lambda_powertools import Logger
+
+logger = Logger()
+
+
+class NumberUtility:
+    """
+    Number Utility.
+    """
+
+    @staticmethod
+    def is_numeric(value: str | None | int | float) -> bool:
+        """
+        Determines if a value is a number or not.  This will remove any dashes, periods "-", "."
+        and then determine if the value is numeric
+        Args:
+            value (str): string value of a number
+
+        Returns:
+            bool: _description_
+        """
+        if value is None:
+            return False
+
+        if value is None:
+            return False
+
+        if str(value).isnumeric():
+            return True
+        try:
+            float(value)
+            return True
+        except:  # noqa: E722, pylint: disable=w0702
+            return False
+
+    @staticmethod
+    def are_numeric(values: List[int] | List[str] | List[float]) -> bool:
+        """determines if a set of values are numeric or not"""
+        for value in values:
+            if not NumberUtility.is_numeric(value):
+                return False
+
+        return True
+
+    @staticmethod
+    def to_number_or_none(value: str) -> float | int | None:
+        """Converts a string to a number."""
+        if value is not None and NumberUtility.is_numeric(value):
+            if "." in str(value):
+                return float(value)
+            else:
+                return int(value)
+        return None
+
+    @staticmethod
+    def to_float(
+        value: str | float | int, raise_errors: Optional[bool] = False
+    ) -> float:
+        """_summary_
+
+        Args:
+            value (str | float | int): _description_
+
+
+
+        Returns:
+            float: returns a float of zero.
+        """
+        try:
+            return float(value)
+        except:  # noqa: E722, pylint: disable=w0702
+            logger.error(f"Unable to convert {value} to float")
+            if raise_errors:
+                raise
+            return 0.0
+
+    @staticmethod
+    def get_max_length(items: List[str] | List[int] | List[float]) -> int:
+        """Returns the max length of an item in a list."""
+        length = 0
+        for item in items:
+            if len(str(item)) > length:
+                length = len(str(item))
+
+        return length
+
+    @staticmethod
+    def to_significant_digits_rounded(value, significant_digits=10):
+        """
+        converts to significant digits
+        """
+        result = math.floor(value * 10**significant_digits) / 10**significant_digits
+        to_the_right = len(f"{int(value)}")
+        f_string_number = (
+            f"{value:.{significant_digits + to_the_right}g}"  # Using f-string
+        )
+        result = float(f_string_number)
+
+        return result
+
+    @staticmethod
+    def get_number_of_decimal_places(number: float) -> int:
+        """
+        Gets the number decimal places
+
+        Args:
+            number (float): the number to inspect
+
+        Returns:
+            int: number of decimal places
+        """
+        number_str = f"{number}"
+        if "." in number_str:
+            to_the_right = number_str.split(".")[1]
+            return len(to_the_right)
+
+        return 0
+
+    @staticmethod
+    def to_significant_digits(number: float, significant_digits: int = 10):
+        """To Significat Digits"""
+        # make sure we're dealing with a number
+        number = float(number)
+        if significant_digits < 0:
+            raise ValueError("Decimal places must be non-negative")
+        else:
+            number_str = f"{number}"
+            if "." in number_str:
+                decimal_point_index = number_str.index(".")
+                number_of_decimal_places = NumberUtility.get_number_of_decimal_places(
+                    number
+                )
+                if number_of_decimal_places > significant_digits:
+                    return NumberUtility.to_significant_digits_rounded(
+                        number, significant_digits
+                    )
+                else:
+                    cutoff_index = decimal_point_index + significant_digits + 1
+                    truncated_str = number_str[:cutoff_index]
+                    return float(truncated_str)
+            else:
+                return number
+
+    @staticmethod
+    def is_decimal(value):
+        is_numeric = NumberUtility.is_numeric(value)
+        contains_decimal = "." in str(value)
+
+        return is_numeric and contains_decimal
+
+    @staticmethod
+    def percent_difference(number1, number2):
+        """
+        Calculate the percent difference between two numbers.
+
+        Parameters:
+        - number1: The first number.
+        - number2: The second number.
+
+        Returns:
+        - The percent difference between the two numbers.
+        """
+        number1 = float(number1)
+        number2 = float(number2)
+        # Calculate the absolute difference between the two numbers
+        difference = abs(number1 - number2)
+
+        # Calculate the average of the two numbers
+        average = (number1 + number2) / 2
+
+        if difference > 0:
+            # Calculate the percent difference
+            percent_diff = (difference / average) * 100
+
+            return percent_diff
+
+        return 0.0
+
+    @staticmethod
+    def to_significant_figure(
+        number: int | float | str, sig_figs: int
+    ) -> int | float | str:
+        """
+        Formats a number to it's significant figures.
+        Examples
+             12345.6789, 4 = 12350
+
+        Args:
+            number (int | float | str): a valid number
+            sig_figs (int): the number of signigicant figures
+
+        Returns:
+            int | float: the value after applying a significant figure
+        """
+        # just used for tracking
+        original_value = number
+        value: int | float | str = 0
+        if str(number).lower() == "nan":
+            return number
+
+        if NumberUtility.is_numeric(number) and isinstance(number, str):
+            if "." in str(number):
+                number = float(number)
+            else:
+                number = int(number)
+
+        if number == 0:
+            if sig_figs > 1:
+                value = "0." + "0" * (sig_figs - 1)
+            else:
+                value = 0
+
+        else:
+            scale = int(math.floor(math.log10(abs(float(number)))))
+            pre_power = int(scale - sig_figs + 1)
+
+            factor = 10 ** (pre_power)
+            rounded = round(number / factor) * factor
+
+            if not isinstance(rounded, int):
+                value = f"{rounded:.{sig_figs}g}"
+            else:
+                value = f"{rounded}"
+
+        if "." in f"{value}" and len(f"{value}") >= (sig_figs):
+            value = float(value)
+        elif "." in f"{value}" and len(f"{value}") <= (sig_figs + 1):
+            # there are more sig figures in the length of the figures
+            # adding 1 to account for the decimal place
+            value = float(value)
+        else:
+            # due to the scientific express we need to float it first
+            value = float(value)
+            value = int(value)
+
+        logger.debug(
+            {
+                "source": "",
+                "sig": sig_figs,
+                "value": {"original": original_value, "converted": value},
+            }
+        )
+
+        return value
+
+    @staticmethod
+    def get_significant_figure(value) -> int:
+        """
+        Calculate the number of significant figures in a number.
+        Removes leading and trailing zeros for float numbers.
+        """
+        if not value:
+            return 0
+        if isinstance(value, int) or isinstance(value, int):
+            return len(str(value).strip("0"))
+        elif isinstance(value, float):
+            if value == 0:
+                return 0
+            else:
+                length: int = 0
+                if value > 1:
+                    value_str = f"{value}"
+                    digits = value_str
+                    number = digits.split(".")
+                    left = number[0].lstrip("0")
+                    right = ""
+                    if len(number) > 1:
+                        right = f"{number[1].rstrip('0')}"
+
+                    digits_stripped = f"{left}{right}"
+                    # Remove decimal point and trailing zeros
+                    length = len(digits_stripped)
+
+                else:
+                    value_str = f"{value}"
+                    # remove the "." remove all left and right decimals
+                    # example: 0.0012 becomes 12 with sig digit of 2
+                    digits_stripped = value_str.replace(".", "").rstrip("0").lstrip("0")
+                    length = len(digits_stripped)
+
+                return length
+
+        else:
+            return 0

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/utilities/string_utility.py

@@ -7,11 +7,13 @@ MIT License.  See Project Root for the license information.
 import hashlib
 import secrets
 import string
+import time
 from datetime import datetime
 from decimal import Decimal
 import uuid
 import json
 from aws_lambda_powertools import Logger
+from boto3_assist.utilities.datetime_utility import DatetimeUtility
 
 logger = Logger()
 
@@ -230,3 +232,60 @@ class StringUtility:
         size = int(len(_bytes))
 
         return size
+
+    @staticmethod
+    def generate_sortable_uuid():
+        """
+        Generates a unique id for the execution event
+        """
+        epoch_time = time.time()
+        sortable_uuid: uuid.UUID = DatetimeUtility.uuid1_utc(timestamp=epoch_time)
+
+        time_stamp = str(epoch_time).replace(".", "-")
+        sortable_id = f"{time_stamp}:{str(sortable_uuid)}"
+        return sortable_id
+
+    @staticmethod
+    def to_bool(value: str | bool | int | None) -> bool:
+        """
+        Converts a string or boolean value to a boolean.
+
+        Args:
+            value (str | bool | int | None): The value to convert.
+
+        Returns:
+            bool: The converted boolean value.
+
+        Raises:
+            ValueError: If the input value is not a valid boolean or string representation.
+        """
+        return StringUtility.to_boolean(value)
+
+    @staticmethod
+    def to_boolean(value: str | bool | int | None) -> bool:
+        """
+        Converts a string or boolean value to a boolean.
+
+        Args:
+            value (str | bool | int | None): The value to convert.
+
+        Returns:
+            bool: The converted boolean value.
+
+        Raises:
+            ValueError: If the input value is not a valid boolean or string representation.
+        """
+        if isinstance(value, bool):
+            return value
+        if isinstance(value, str):
+            value = str(value).lower().strip()
+            if value in ("true", "1", "t", "y", "yes"):
+                return True
+            if value in ("false", "0", "f", "n", "no"):
+                return False
+        elif isinstance(value, int):
+            return bool(value)
+        elif value is None:
+            return False
+        else:
+            raise ValueError(f"Invalid boolean value: {value}")

boto3_assist/version.py

@@ -1 +1 @@
-__version__ = '0.4.0'
+__version__ = '0.5.1'

{boto3_assist-0.4.0.dist-info → boto3_assist-0.5.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boto3_assist
-Version: 0.4.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.4.0.dist-info → boto3_assist-0.5.1.dist-info}/RECORD

@@ -1,9 +1,9 @@
 boto3_assist/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-boto3_assist/boto3session.py,sha256=NWhWtYR3143thEbTpoklkwdz77-fTMs-QsoQdqfRm6E,6430
-boto3_assist/connection.py,sha256=EJlGueLIYqMSKs7aQlThK1S0Zkb8dOYBWch1iRZdgUI,3233
-boto3_assist/connection_tracker.py,sha256=_s1t7h2DOi3CCIHIr_HIKyGjku65WR-HJ_v8vJHDvO0,2977
+boto3_assist/boto3session.py,sha256=Q9sByNC0r_aMQfHnIEnxtTaiCMUqikm8UeSTxV7-Np0,6632
+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=2eiWQI55fd-roDdkt4Hvl9WzrTJ4xQo33VzFud6D03U,22
+boto3_assist/version.py,sha256=s8Yq9Om1yBxrMA7xYQ5Y13Paeuxnq99NxhyjuPlnH6A,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
@@ -11,10 +11,12 @@ boto3_assist/cloudwatch/cloudwatch_log_connection.py,sha256=qQMZHjUJ6gA8wU9utjQh
 boto3_assist/cloudwatch/cloudwatch_logs.py,sha256=VtI0OnFjX1l4RYVvA8tvveGkPwAogtrplnflZ4dQSNM,1204
 boto3_assist/cloudwatch/cloudwatch_query.py,sha256=uNhSb1Gfp99v8BaHmCnCKs63j4MMU4WveqBavCJyhGY,6409
 boto3_assist/cognito/cognito_authorizer.py,sha256=ONcxzjTACgVYl6qI9kJAQ5SoRMtVHYGDeuKi5QqJvOY,5837
+boto3_assist/cognito/cognito_connection.py,sha256=deuXR3cNHz0mCYff2k0LfAvK--9OkqehWp0Bl--lDuw,1607
+boto3_assist/cognito/cognito_utility.py,sha256=kjzd2PcCCP9GbxlMlgYEIQE1FSyPPjsRPjr6-kN08Jc,18238
 boto3_assist/cognito/jwks_cache.py,sha256=1Y9r-YfQ8qrgZN5xYPvjUEEV0vthbdcPdAIaPbZP7kU,373
+boto3_assist/cognito/user.py,sha256=qc44qLx3gwq6q2zMxcPQze1EjeZwy5Kuav93vbe-4WU,820
 boto3_assist/dynamodb/dynamodb.py,sha256=q3U4uYqnKX1_u5TXv8Iq94JrBad16q0rL_vKxQyR_3k,15772
-boto3_assist/dynamodb/dynamodb_connection.py,sha256=hr4IGbbEE73fh375tj3_XtYAwwDV0s7z1-6JK_1Tc30,5263
-boto3_assist/dynamodb/dynamodb_connection_tracker.py,sha256=0BWHRfi5_vjkJLuCSX6sYwvA6wc7BSYCQnGrzbhfyKA,404
+boto3_assist/dynamodb/dynamodb_connection.py,sha256=x6Ylb_uVAY5TS0AIBUNOSyywKIqros3xX8diLTjZUsc,3275
 boto3_assist/dynamodb/dynamodb_helpers.py,sha256=ajpTJ5bJOm9PDgE2Zx9p2zkTRFV4xswqJRS81SOTn1s,12198
 boto3_assist/dynamodb/dynamodb_importer.py,sha256=nCKsyRQeMqDSf0Q5mQ_X_oVIg4PRnu0hcUzZnBli610,3471
 boto3_assist/dynamodb/dynamodb_index.py,sha256=D0Lq121qk1cXeMetPeqnzvv6CXd0XfEygfdUXaljLG8,8551
@@ -27,21 +29,24 @@ boto3_assist/dynamodb/dynamodb_reserved_words.py,sha256=p0irNBSqGe4rd2FwWQqbRJWr
 boto3_assist/dynamodb/dynamodb_reserved_words.txt,sha256=rvctS63Cv3i9SHmPq2Unmj6RZyQ-OMqxUXsNhtbg1is,4136
 boto3_assist/dynamodb/readme.md,sha256=wNMzdRwk0qRV0kE88UUYnJos3pEK0HNjEIVkq2PATf8,1490
 boto3_assist/dynamodb/troubleshooting.md,sha256=uGpBaBUt_MyzjzwFOLOe0udTgcvaOpiTFxfj7ilLNkM,136
-boto3_assist/ec2/ec2_connection.py,sha256=VT_hnu_behs9mf1Prggo5U9c9KAwbnLBTSZkmu4gp30,3277
+boto3_assist/ec2/ec2_connection.py,sha256=IrtaidH6_SF5l3OeNehRsTlC-sX7EURVqcO-U6P6ff8,1318
 boto3_assist/environment_services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-boto3_assist/environment_services/environment_loader.py,sha256=jvG1xwMtgkZqu70NbjG1b1IefKiWgaidjZZoqsSfULk,3370
+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=8CunaU2YDWs9vK2BShShnyAdktmeZ3R_o7p8Yt70nYQ,829
 boto3_assist/s3/s3.py,sha256=DFCJs5z1mMIT8nZfnqPyr_cvhi9-FePuYH--tzD7b5E,17104
-boto3_assist/s3/s3_connection.py,sha256=fMD1FxQazJ9gSFDrRmrv7YJE5QnCesGoWC1b5Dba_Jo,3774
-boto3_assist/utilities/datetime_utility.py,sha256=TbqGQkJDTahqvaZAIV550nhYnW1Bsq0Hdu3Go6P4RRs,10282
+boto3_assist/s3/s3_connection.py,sha256=FI1AhZV4UbTXQRTb4TqL9mv88Gt018rPZVFBvLetVAw,2163
+boto3_assist/utilities/datetime_utility.py,sha256=dgAMB9VqakrYIPXlSoVQiLSsc_yhrJK4gMfJO9mX90w,11112
+boto3_assist/utilities/dictionaroy_utility.py,sha256=PjUrerEd6uhmw37A-k7xe_DWHvXZGGoMqT6xjUqmWBI,893
 boto3_assist/utilities/file_operations.py,sha256=Zy8fu8fpuVNf7U9NimrLdy5FRF71XSI159cnRdzmzGY,3411
 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/serialization_utility.py,sha256=vsipCQZu91hApkJ8tKRTxBa8kNRvn06ED-isquqAVQQ,5744
-boto3_assist/utilities/string_utility.py,sha256=fzsZkldRYtdkIqR0kD-TlHH4fh4iMtYvo_U3UNZhN7U,7427
-boto3_assist-0.4.0.dist-info/METADATA,sha256=6PglW0CMu-LSfBs74ViaxrykaJG96KtCspwIIPcP0PU,1728
-boto3_assist-0.4.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-boto3_assist-0.4.0.dist-info/licenses/LICENSE-EXPLAINED.txt,sha256=WFREvTpfTjPjDHpOLADxJpCKpIla3Ht87RUUGii4ODU,606
-boto3_assist-0.4.0.dist-info/licenses/LICENSE.txt,sha256=PXDhFWS5L5aOTkVhNvoitHKbAkgxqMI2uUPQyrnXGiI,1105
-boto3_assist-0.4.0.dist-info/RECORD,,
+boto3_assist/utilities/numbers_utility.py,sha256=KIiNkBSRbfNWvtXG5SdHp625LTiW12VtADUa4ZlWMFo,8709
+boto3_assist/utilities/serialization_utility.py,sha256=p9QQfc6EDOtD-mB6Ujhv-BRpDn3DCCG2z5VmXG1kmb0,7768
+boto3_assist/utilities/string_utility.py,sha256=sBY80aQO-fTRanlHryZFMQBxdo6OvLRvnZjZrQepHlI,9283
+boto3_assist-0.5.1.dist-info/METADATA,sha256=r5iNwKDiUS06CIskAGuHnpvW3wXfD97QznVQhe07jWQ,1728
+boto3_assist-0.5.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+boto3_assist-0.5.1.dist-info/licenses/LICENSE-EXPLAINED.txt,sha256=WFREvTpfTjPjDHpOLADxJpCKpIla3Ht87RUUGii4ODU,606
+boto3_assist-0.5.1.dist-info/licenses/LICENSE.txt,sha256=PXDhFWS5L5aOTkVhNvoitHKbAkgxqMI2uUPQyrnXGiI,1105
+boto3_assist-0.5.1.dist-info/RECORD,,

boto3_assist/dynamodb/dynamodb_connection_tracker.py

@@ -1,17 +0,0 @@
-"""
-Geek Cafe, LLC
-Maintainers: Eric Wilson
-MIT License.  See Project Root for the license information.
-"""
-
-from boto3_assist.connection_tracker import ConnectionTracker
-
-
-class DynamoDBConnectionTracker(ConnectionTracker):
-    """
-    Tracks DynamoDB Connection Requests.
-    Useful in for performance tuning and debugging.
-    """
-
-    def __init__(self) -> None:
-        super().__init__("DynamoDB")