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

{boto3_assist-0.6.1 → boto3_assist-0.8.0}/PKG-INFO

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

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

{boto3_assist-0.6.1 → boto3_assist-0.8.0}/src/boto3_assist/connection_tracker.py

@@ -67,8 +67,8 @@ class ConnectionTracker:
 
             if not self.issue_stack_trace:
                 stack_trace_message = (
-                    f"\nTo add additional information to the log and determine where additional connections are being created, "
-                    f"set the environment variable {self.__stack_trace_env_var} to true.\n"
+                    f"📄 NOTE: To add additional information 👀 to the log and determine where additional connections are being created: "
+                    f"set the environment variable 👉{self.__stack_trace_env_var}👈 to true ✅. \n"
                 )
             else:
                 stack = "\n".join(traceback.format_stack())
@@ -83,8 +83,8 @@ class ConnectionTracker:
                 "instead of creating a new one. Connections are expensive in terms of time and latency. "
                 "If you are seeing performance issues, check how and where you are creating your "
                 "connections. You should be able to pass the connection to your other objects "
-                "and reuse your boto3 connections."
-                "\n\nMOCK Testing may show this message as well, in which case you can dismiss this warning.\n\n"
+                "and reuse your boto3 connections. "
+                "\n🧪 MOCK Testing may show this message as well, in which case you can dismiss this warning.🧪\n"
                 f"{stack_trace_message}"
             )
 

boto3_assist-0.8.0/src/boto3_assist/s3/s3.py

@@ -0,0 +1,64 @@
+"""
+Geek Cafe, LLC
+Maintainers: Eric Wilson
+MIT License.  See Project Root for the license information.
+"""
+
+from typing import Optional, cast
+
+from aws_lambda_powertools import Logger
+
+from boto3_assist.s3.s3_connection import S3Connection
+from boto3_assist.s3.s3_object import S3Object
+from boto3_assist.s3.s3_bucket import S3Bucket
+
+logger = Logger(child=True)
+
+
+class S3(S3Connection):
+    """Common S3 Actions"""
+
+    def __init__(
+        self,
+        *,
+        aws_profile: Optional[str] = None,
+        aws_region: Optional[str] = None,
+        aws_end_point_url: Optional[str] = None,
+        aws_access_key_id: Optional[str] = None,
+        aws_secret_access_key: Optional[str] = None,
+    ) -> None:
+        """_summary_
+
+        Args:
+            aws_profile (Optional[str], optional): _description_. Defaults to None.
+            aws_region (Optional[str], optional): _description_. Defaults to None.
+            aws_end_point_url (Optional[str], optional): _description_. Defaults to None.
+            aws_access_key_id (Optional[str], optional): _description_. Defaults to None.
+            aws_secret_access_key (Optional[str], optional): _description_. Defaults to None.
+        """
+        super().__init__(
+            aws_profile=aws_profile,
+            aws_region=aws_region,
+            aws_end_point_url=aws_end_point_url,
+            aws_access_key_id=aws_access_key_id,
+            aws_secret_access_key=aws_secret_access_key,
+        )
+
+        self.__s3_object: S3Object | None = None
+        self.__s3_bucket: S3Bucket | None = None
+
+    @property
+    def object(self) -> S3Object:
+        """s3 object"""
+        if self.__s3_object is None:
+            connection = cast(S3Connection, self)
+            self.__s3_object = S3Object(connection)
+        return self.__s3_object
+
+    @property
+    def bucket(self) -> S3Bucket:
+        """s3 bucket"""
+        if self.__s3_bucket is None:
+            connection = cast(S3Connection, self)
+            self.__s3_bucket = S3Bucket(connection)
+        return self.__s3_bucket

boto3_assist-0.8.0/src/boto3_assist/s3/s3_bucket.py

@@ -0,0 +1,67 @@
+"""
+Geek Cafe, LLC
+Maintainers: Eric Wilson
+MIT License.  See Project Root for the license information.
+"""
+
+from typing import Any, Dict
+
+from aws_lambda_powertools import Logger
+from botocore.exceptions import ClientError
+
+
+from boto3_assist.s3.s3_connection import S3Connection
+
+logger = Logger(child=True)
+
+
+class S3Bucket:
+    """Common S3 Actions"""
+
+    def __init__(self, connection: S3Connection):
+        self.connection = connection or S3Connection()
+
+    def create(self, *, bucket_name: str) -> Dict[str, Any]:
+        """
+        Create an S3 bucket
+        :param bucket_name: Bucket to create
+        :return: True if bucket is created, else False
+        """
+        try:
+            response = self.connection.client.create_bucket(Bucket=bucket_name)
+            logger.info(f"Bucket {bucket_name} created")
+
+            return dict(response)
+        except ClientError as e:
+            logger.exception(e)
+            raise e
+
+    def enable_versioning(self, *, bucket_name: str) -> None:
+        """
+        Enable versioning on an S3 bucket
+        :param bucket_name: Bucket to enable versioning on
+        :return: None
+        """
+        try:
+            self.connection.client.put_bucket_versioning(
+                Bucket=bucket_name, VersioningConfiguration={"Status": "Enabled"}
+            )
+            logger.info(f"Versioning enabled on bucket {bucket_name}")
+        except ClientError as e:
+            logger.exception(e)
+            raise e
+
+    def disable_versioning(self, *, bucket_name: str) -> None:
+        """
+        Disable versioning on an S3 bucket
+        :param bucket_name: Bucket to disable versioning on
+        :return: None
+        """
+        try:
+            self.connection.client.put_bucket_versioning(
+                Bucket=bucket_name, VersioningConfiguration={"Status": "Suspended"}
+            )
+            logger.info(f"Versioning disabled on bucket {bucket_name}")
+        except ClientError as e:
+            logger.exception(e)
+            raise e

{boto3_assist-0.6.1 → boto3_assist-0.8.0}/src/boto3_assist/s3/s3_connection.py

@@ -8,10 +8,7 @@ from typing import Optional
 from typing import TYPE_CHECKING
 
 from aws_lambda_powertools import Logger
-from boto3_assist.boto3session import Boto3SessionManager
-from boto3_assist.environment_services.environment_variables import (
-    EnvironmentVariables,
-)
+
 from boto3_assist.connection import Connection
 
 if TYPE_CHECKING:

boto3_assist-0.6.1/src/boto3_assist/s3/s3.py → boto3_assist-0.8.0/src/boto3_assist/s3/s3_object.py

@@ -8,7 +8,7 @@ import os
 import tempfile
 import time
 import io
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, Optional, List
 
 from aws_lambda_powertools import Logger
 from botocore.exceptions import ClientError
@@ -19,61 +19,100 @@ from boto3_assist.utilities.datetime_utility import DatetimeUtility
 from boto3_assist.utilities.file_operations import FileOperations
 from boto3_assist.utilities.http_utility import HttpUtility
 
+
 logger = Logger(child=True)
 
 
-class S3(S3Connection):
-    """Common S3 Actions"""
+class S3Object:
+    """S3 Object Actions"""
 
-    def __init__(
-        self,
-        *,
-        aws_profile: Optional[str] = None,
-        aws_region: Optional[str] = None,
-        aws_end_point_url: Optional[str] = None,
-        aws_access_key_id: Optional[str] = None,
-        aws_secret_access_key: Optional[str] = None,
-    ) -> None:
-        """_summary_
+    def __init__(self, connection: S3Connection):
+        self.connection = connection or S3Connection()
 
-        Args:
-            aws_profile (Optional[str], optional): _description_. Defaults to None.
-            aws_region (Optional[str], optional): _description_. Defaults to None.
-            aws_end_point_url (Optional[str], optional): _description_. Defaults to None.
-            aws_access_key_id (Optional[str], optional): _description_. Defaults to None.
-            aws_secret_access_key (Optional[str], optional): _description_. Defaults to None.
+    def delete(self, *, bucket_name: str, key: str) -> Dict[str, Any]:
         """
-        super().__init__(
-            aws_profile=aws_profile,
-            aws_region=aws_region,
-            aws_end_point_url=aws_end_point_url,
-            aws_access_key_id=aws_access_key_id,
-            aws_secret_access_key=aws_secret_access_key,
-        )
+        Deletes an object key
 
-    def create_bucket(self, *, bucket_name: str) -> None:
-        """
-        Create an S3 bucket
-        :param bucket_name: Bucket to create
-        :return: True if bucket is created, else False
+        Args:
+            bucket_name (str): The AWS Bucket Name
+            key (str): The Object Key
         """
+        s3 = self.connection.client
+        # see if the object exists
         try:
-            self.client.create_bucket(Bucket=bucket_name)
-            logger.info(f"Bucket {bucket_name} created")
-        except ClientError as e:
-            logger.exception(e)
-            raise e
+            response = s3.head_object(Bucket=bucket_name, Key=key)
+            response = s3.delete_object(Bucket=bucket_name, Key=key)
+        except s3.exceptions.NoSuchKey:
+            response = {"ResponseMetadata": {"HTTPStatusCode": 404}}
+        except s3.exceptions.ClientError as e:
+            if e.response.get("Error", {}).get("Code") == "404":
+                response = {"ResponseMetadata": {"HTTPStatusCode": 404}}
+            else:
+                raise e
+
+        return dict(response)
+
+    def delete_all_versions(
+        self, *, bucket_name: str, key: str, include_deleted: bool = False
+    ) -> List[str]:
+        """
+        Deletes an object key and all the versions for that object key
+
+        Args:
+            bucket_name (str): The AWS Bucket Name
+            key (str): The Object Kuye
+            include_deleted (bool, optional): Should deleted files be removed as well.
+                If True it will look for the object keys with the deleted marker and remove it.
+                Defaults to False.
+        """
+        s3 = self.connection.client
+        paginator = s3.get_paginator("list_object_versions")
+        files: List[str] = []
+
+        for page in paginator.paginate(Bucket=bucket_name, Prefix=key):
+            # Delete object versions
+            if "Versions" in page:
+                for version in page["Versions"]:
+                    s3.delete_object(
+                        Bucket=bucket_name,
+                        Key=version["Key"],
+                        VersionId=version["VersionId"],
+                    )
+
+                    files.append(f"{version['Key']} - {version['VersionId']}")
+
+                if include_deleted:
+                    # delete a previous files that may have just been a soft delete.
+                    if "DeleteMarkers" in page:
+                        for marker in page["DeleteMarkers"]:
+                            s3.delete_object(
+                                Bucket=bucket_name,
+                                Key=marker["Key"],
+                                VersionId=marker["VersionId"],
+                            )
+
+                            files.append(
+                                f"{marker['Key']}:{marker['VersionId']}:delete-marker"
+                            )
+            else:
+                response = self.delete(bucket_name=bucket_name, key=key)
+                if response["ResponseMetadata"]["HTTPStatusCode"] == 404:
+                    return files
+
+                files.append(key)
+
+        return files
 
     def generate_presigned_url(
         self,
         *,
         bucket_name: str,
         key_path: str,
-        user_id: str,
         file_name: str,
-        meta_data: dict | None = None,
-        expiration=3600,
-        method_type="POST",
+        meta_data: Optional[dict] = None,
+        expiration: int = 3600,
+        method_type: str = "POST",
+        user_id: Optional[str] = None,
     ) -> Dict[str, Any]:
         """
         Create a signed URL for uploading a file to S3.
@@ -109,7 +148,7 @@ class S3(S3Connection):
 
         signed_url: str | Dict[str, Any]
         if method_type == "PUT":
-            signed_url = self.client.generate_presigned_url(
+            signed_url = self.connection.client.generate_presigned_url(
                 "put_object",
                 Params={
                     "Bucket": f"{bucket_name}",
@@ -124,13 +163,13 @@ class S3(S3Connection):
                 ExpiresIn=expiration,  # URL is valid for x seconds
             )
         elif method_type == "POST":
-            signed_url = self.client.generate_presigned_post(
+            signed_url = self.connection.client.generate_presigned_post(
                 bucket_name,
                 key,
                 ExpiresIn=expiration,  # URL is valid for x seconds
             )
         elif method_type == "GET":
-            signed_url = self.client.generate_presigned_url(
+            signed_url = self.connection.client.generate_presigned_url(
                 "get_object",
                 Params={
                     "Bucket": f"{bucket_name}",
@@ -175,7 +214,7 @@ class S3(S3Connection):
             file_obj: bytes = (
                 file_obj.encode("utf-8") if isinstance(file_obj, str) else file_obj
             )
-            self.client.upload_fileobj(
+            self.connection.client.upload_fileobj(
                 Fileobj=io.BytesIO(file_obj), Bucket=bucket, Key=key
             )
 
@@ -219,7 +258,7 @@ class S3(S3Connection):
             }
         )
         try:
-            self.client.upload_file(local_file_path, bucket, key)
+            self.connection.client.upload_file(local_file_path, bucket, key)
 
         except ClientError as ce:
             error = {
@@ -394,7 +433,9 @@ class S3(S3Connection):
         error = None
 
         try:
-            response = dict(self.client.get_object(Bucket=bucket_name, Key=key))
+            response = dict(
+                self.connection.client.get_object(Bucket=bucket_name, Key=key)
+            )
 
             logger.debug(
                 {"metric_filter": "s3_download_response", "response": str(response)}
@@ -465,7 +506,7 @@ class S3(S3Connection):
 
         error: str | None = None
         try:
-            self.client.download_file(bucket, key, local_path)
+            self.connection.client.download_file(bucket, key, local_path)
 
         except Exception as e:  # pylint: disable=W0718
             error = str(e)
@@ -542,3 +583,24 @@ class S3(S3Connection):
         Decodes bytes to a string
         """
         return file_obj.decode(encoding=encoding, errors=errors)
+
+    def list_versions(self, bucket: str, prefix: str = "") -> List[str]:
+        """
+        List all versions of objects in an S3 bucket with a given prefix.
+
+        Args:
+            bucket (str): The name of the S3 bucket.
+            prefix (str, optional): The prefix to filter objects by. Defaults to "".
+
+        Returns:
+            list: A list of dictionaries containing information about each object version.
+        """
+        versions = []
+        paginator = self.connection.client.get_paginator("list_object_versions")
+        page_iterator = paginator.paginate(Bucket=bucket, Prefix=prefix)
+
+        for page in page_iterator:
+            if "Versions" in page:
+                versions.extend(page["Versions"])
+
+        return versions

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

@@ -308,19 +308,30 @@ class Serialization:
                     )
                     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 not Serialization.has_setter(target, key):
+                        logger.warning(
+                            f"Error warning attempting to set attribute {key} with value {value}: {e}. "
+                            "This usually occurs on properties that don't have setters. "
+                            "You should add a setter (even with a pass action) for this property or "
+                            "decorate it with the @exclude_from_serialization to avoid this warning."
+                        )
+                    else:
+                        raise e
 
         if hasattr(target, "__actively_serializing_data__"):
             setattr(target, "__actively_serializing_data__", False)
 
         return target
 
+    @staticmethod
+    def has_setter(obj: object, attr_name: str) -> bool:
+        """Check if the given attribute has a setter defined."""
+        cls = obj.__class__
+        if not hasattr(cls, attr_name):
+            return False
+        attr = getattr(cls, attr_name, None)
+        return isinstance(attr, property) and attr.fset is not None
+
     @staticmethod
     def has_attribute(obj: object, attribute_name: str) -> bool:
         """Check if an object has an attribute"""

{boto3_assist-0.6.1 → boto3_assist-0.8.0}/src/boto3_assist/utilities/string_utility.py

@@ -195,6 +195,36 @@ class StringUtility:
         hash_object.update(encoded_string)
         return hash_object.hexdigest()
 
+    @staticmethod
+    def generate_idempotent_uuid(
+        namespace: uuid.UUID | str, unique_string: str, case_sensitive: bool = False
+    ) -> str:
+        """
+        Generates an idempotnent UUID, which is useful for creates
+
+        Args:
+            namespace (GUID | str): A namespace for your id, it must be a UUID or a string in a UUID format
+            unique_string (str): A unique string like an email address, a tenant name.
+                Use a combination for more granularity:
+                    tenant-name:email
+                    vendor:product-name
+                    vendor:product-id
+                    etc
+
+        Returns:
+            str: a string representation of a UUID
+        """
+        if isinstance(namespace, str):
+            namespace = uuid.UUID(namespace)
+
+        if not unique_string:
+            raise ValueError("unique_string cannot be empty")
+
+        if not case_sensitive:
+            unique_string = unique_string.lower()
+
+        return str(uuid.uuid5(namespace, unique_string))
+
     @staticmethod
     def get_size_in_kb(input_string: str | dict) -> float:
         """

boto3_assist-0.8.0/src/boto3_assist/version.py

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

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

@@ -8,12 +8,18 @@ import os
 import sys
 from pathlib import Path
 
-## needed for discovery based top level execution
-print("👋 init test paths for __top")
+VERBOSE: bool = os.getenv("VERBOSE") or False
+
+if VERBOSE:
+    print("👋 init test paths for __top")
+
+
 root_directory = Path(__file__).resolve().parent.parent.parent
 src_directory = os.path.join(root_directory, "src")
-
+# inject src path to python search path
 sys.path.insert(0, src_directory)
-print("")
-for p in sys.path:
-    print(f"👉 {p}")
+
+if VERBOSE:
+    print("")
+    for p in sys.path:
+        print(f"👉 {p}")

boto3_assist-0.8.0/tests/s3/s3_file_delete_test.py

@@ -0,0 +1,123 @@
+import os
+import unittest
+from pathlib import Path
+
+import moto
+
+from boto3_assist.environment_services.environment_loader import EnvironmentLoader
+from boto3_assist.s3.s3 import S3
+
+
+@moto.mock_aws
+class S3FileDeleteTest(unittest.TestCase):
+    """Test S3 File Upload"""
+
+    def setUp(self):
+        """Setup"""
+        ev: EnvironmentLoader = EnvironmentLoader()
+        # NOTE: you need to make sure the the env file below exists or you will get an error
+        ev.load_environment_file(file_name=".env.unittest")
+
+    def test_delete_file(self):
+        """Test uploading a file"""
+        s3 = S3()
+        bucket_name: str = "test-bucket"
+        s3.bucket.create(bucket_name=bucket_name)
+        s3.bucket.enable_versioning(bucket_name=bucket_name)
+        local_file_path: Path = Path(
+            os.path.join(os.path.dirname(__file__), "files", "test.txt")
+        )
+        if not os.path.exists(local_file_path):
+            raise FileNotFoundError(f"File not found: {local_file_path}")
+
+        for _ in range(0, 5):
+            # upload the same file over and over, it should create different versions
+            s3.object.upload_file(
+                bucket=bucket_name, key="test.txt", local_file_path=local_file_path
+            )
+
+        files = s3.object.delete_all_versions(bucket_name=bucket_name, key="test.txt")
+
+        self.assertEqual(len(files), 5)
+
+    def test_delete_file_including_delete_markers(self):
+        """Test uploading a file"""
+        s3 = S3()
+        bucket_name: str = "unittest-bucket"
+        test_file_name = "test.txt"
+        key = "test_with_delete.txt"
+        s3.bucket.create(bucket_name=bucket_name)
+        s3.bucket.enable_versioning(bucket_name=bucket_name)
+        local_file_path: Path = Path(
+            os.path.join(os.path.dirname(__file__), "files", test_file_name)
+        )
+        if not os.path.exists(local_file_path):
+            raise FileNotFoundError(f"File not found: {local_file_path}")
+
+        for _ in range(0, 5):
+            # upload the same file over and over, it should create different versions
+            s3.object.upload_file(
+                bucket=bucket_name, key=key, local_file_path=local_file_path
+            )
+
+        files = s3.object.delete_all_versions(
+            bucket_name=bucket_name, key=key, include_deleted=True
+        )
+
+        # we should have ten here, the original 5 and the deleted 5
+        self.assertEqual(len(files), 5)
+
+        files = s3.object.delete_all_versions(
+            bucket_name=bucket_name, key=key, include_deleted=True
+        )
+
+        # we shouldn't have any more files here
+        self.assertEqual(len(files), 0)
+
+    def test_delete_file_including_delete_markers_2(self):
+        """Test uploading a file"""
+        s3 = S3()
+        bucket_name: str = "unittest-bucket"
+        test_file_name = "test.txt"
+        key = "test_with_delete.txt"
+
+        s3.bucket.create(bucket_name=bucket_name)
+
+        s3.bucket.enable_versioning(bucket_name=bucket_name)
+        local_file_path: Path = Path(
+            os.path.join(os.path.dirname(__file__), "files", test_file_name)
+        )
+        if not os.path.exists(local_file_path):
+            raise FileNotFoundError(f"File not found: {local_file_path}")
+
+        for _ in range(0, 5):
+            # upload the same file over and over, it should create different versions
+            s3.object.upload_file(
+                bucket=bucket_name, key=key, local_file_path=local_file_path
+            )
+
+        # delete the latest which should add a deleted marker
+        s3.object.delete(bucket_name=bucket_name, key=key)
+
+        files = s3.object.delete_all_versions(
+            bucket_name=bucket_name, key=key, include_deleted=True
+        )
+
+        # we should have ten here, the original 5 and the 1 deleted marker
+        self.assertEqual(len(files), 6)
+
+        files = s3.object.delete_all_versions(
+            bucket_name=bucket_name, key=key, include_deleted=True
+        )
+
+        # we shouldn't have any more files here
+        self.assertEqual(len(files), 0)
+
+
+def main():
+    """Main"""
+    unittest.main()
+
+
+if __name__ == "__main__":
+    main()

{boto3_assist-0.6.1 → boto3_assist-0.8.0}/tests/s3/s3_file_upload_test.py

@@ -1,9 +1,11 @@
 import os
 import unittest
-import moto
 from pathlib import Path
-from boto3_assist.s3.s3 import S3
+
+import moto
+
 from boto3_assist.environment_services.environment_loader import EnvironmentLoader
+from boto3_assist.s3.s3 import S3
 from boto3_assist.utilities.file_operations import FileOperations
 
 
@@ -21,14 +23,14 @@ class S3FileUploadTest(unittest.TestCase):
         """Test uploading a file"""
         s3 = S3()
         bucket_name: str = "test-bucket"
-        s3.create_bucket(bucket_name=bucket_name)
+        s3.bucket.create(bucket_name=bucket_name)
         local_file_path: Path = Path(
             os.path.join(os.path.dirname(__file__), "files", "test.txt")
         )
         if not os.path.exists(local_file_path):
             raise FileNotFoundError(f"File not found: {local_file_path}")
 
-        s3.upload_file(
+        s3.object.upload_file(
             bucket=bucket_name, key="test.txt", local_file_path=local_file_path
         )
 
@@ -36,7 +38,7 @@ class S3FileUploadTest(unittest.TestCase):
         """Test uploading a file"""
         s3 = S3()
         bucket_name: str = "test-bucket"
-        s3.create_bucket(bucket_name=bucket_name)
+        s3.bucket.create(bucket_name=bucket_name)
         local_file_path: Path = Path(
             os.path.join(os.path.dirname(__file__), "files", "test.txt")
         )
@@ -45,4 +47,4 @@ class S3FileUploadTest(unittest.TestCase):
 
         data = FileOperations.read_file(local_file_path)
 
-        s3.upload_file_obj(bucket=bucket_name, key="test.txt", file_obj=data)
+        s3.object.upload_file_obj(bucket=bucket_name, key="test.txt", file_obj=data)

boto3_assist-0.8.0/tests/utilities/string_utility_test.py

@@ -0,0 +1,56 @@
+"""
+Geek Cafe, LLC
+Maintainers: Eric Wilson
+MIT License.  See Project Root for the license information.
+"""
+
+import unittest
+from datetime import datetime, UTC
+from datetime import timedelta
+from typing import cast
+
+from boto3_assist.utilities.string_utility import StringUtility
+import uuid
+
+
+class StringUtilityUnitTest(unittest.TestCase):
+    "String Utility Tests"
+
+    def test_uuid_idempotency(self):
+        """Testing Idempotnent UUID generation."""
+        # must be consistent
+        namespace: uuid.UUID = uuid.UUID("6ba7b810-9dad-11d1-80b4-00c04fd430c8")
+
+        idempotent_id_john_smith: str = StringUtility.generate_idempotent_uuid(
+            str(namespace), "tenant-one:john.smith@tenant-one.com"
+        )
+
+        # should always get this GUID
+        self.assertEqual(
+            idempotent_id_john_smith, "3e68597f-3a32-5f82-a028-010f34eccfe6"
+        )
+
+        idempotent_id_john_smith_camel: str = StringUtility.generate_idempotent_uuid(
+            namespace, "tenant-one:John.Smith@tenant-one.com", case_sensitive=True
+        )
+
+        # should always get this GUID
+        self.assertEqual(
+            idempotent_id_john_smith_camel, "06daa067-77e1-56c1-80d5-8ee8306d0298"
+        )
+
+        idempotent_id_john_smith_case_insensitive: str = (
+            StringUtility.generate_idempotent_uuid(
+                namespace,
+                "tenant-one:John.Smith@tenant-one.com",
+                case_sensitive=False,
+            )
+        )
+        self.assertEqual(
+            idempotent_id_john_smith_case_insensitive,
+            "3e68597f-3a32-5f82-a028-010f34eccfe6",
+        )
+
+        self.assertEqual(
+            idempotent_id_john_smith, idempotent_id_john_smith_case_insensitive
+        )

boto3_assist-0.6.1/src/boto3_assist/version.py

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