boto3-assist 0.34.0__tar.gz → 0.35.0__tar.gz

{boto3_assist-0.34.0 → boto3_assist-0.35.0}/.gitignore

@@ -173,3 +173,5 @@ activate.sh
 .pypirc
 .DS_Store
 .prompts
+.output
+.outputs

{boto3_assist-0.34.0 → boto3_assist-0.35.0}/PKG-INFO

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

@@ -15,7 +15,7 @@ addopts = "-m 'not integration'"
 
 [project]
 name = "boto3_assist"
-version = "0.34.0"
+version = "0.35.0"
 
 authors = [
   { name="Eric Wilson", email="boto3-assist@geekcafe.com" }

boto3_assist-0.35.0/src/boto3_assist/sqs/__init__.py

@@ -0,0 +1,12 @@
+"""
+SQS module for boto3-assist.
+
+Geek Cafe, LLC
+Maintainers: Eric Wilson
+MIT License. See Project Root for the license information.
+"""
+
+from boto3_assist.sqs.sqs_connection import SQSConnection
+from boto3_assist.sqs.sqs_queue import SQSQueue
+
+__all__ = ["SQSConnection", "SQSQueue"]

boto3_assist-0.35.0/src/boto3_assist/sqs/sqs_connection.py

@@ -0,0 +1,88 @@
+"""
+SQS Connection module.
+
+Geek Cafe, LLC
+Maintainers: Eric Wilson
+MIT License. See Project Root for the license information.
+"""
+
+from typing import Optional, TYPE_CHECKING
+
+from aws_lambda_powertools import Logger
+
+from boto3_assist.connection import Connection
+
+if TYPE_CHECKING:
+    from mypy_boto3_sqs import SQSClient, SQSServiceResource
+else:
+    SQSClient = object
+    SQSServiceResource = object
+
+
+logger = Logger(child=True)
+
+
+class SQSConnection(Connection):
+    """SQS Connection wrapper."""
+
+    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:
+        """
+        Initialize SQS connection.
+
+        Args:
+            aws_profile: AWS profile name
+            aws_region: AWS region
+            aws_end_point_url: Custom endpoint URL (for LocalStack, etc.)
+            aws_access_key_id: AWS access key ID
+            aws_secret_access_key: AWS secret access key
+        """
+        super().__init__(
+            service_name="sqs",
+            aws_profile=aws_profile,
+            aws_region=aws_region,
+            aws_access_key_id=aws_access_key_id,
+            aws_secret_access_key=aws_secret_access_key,
+            aws_end_point_url=aws_end_point_url,
+        )
+
+        self.__client: SQSClient | None = None
+        self.__resource: SQSServiceResource | None = None
+
+    @property
+    def client(self) -> SQSClient:
+        """Get SQS client."""
+        if self.__client is None:
+            self.__client = self.session.client
+        return self.__client
+
+    @client.setter
+    def client(self, value: SQSClient) -> None:
+        """Set SQS client."""
+        logger.info("Setting SQS Client")
+        self.__client = value
+
+    @property
+    def resource(self) -> SQSServiceResource:
+        """Get SQS resource."""
+        if self.__resource is None:
+            logger.info("Creating SQS Resource")
+            self.__resource = self.session.resource
+
+        if self.raise_on_error and self.__resource is None:
+            raise RuntimeError("SQS Resource is not available")
+
+        return self.__resource
+
+    @resource.setter
+    def resource(self, value: SQSServiceResource) -> None:
+        """Set SQS resource."""
+        logger.info("Setting SQS Resource")
+        self.__resource = value

boto3_assist-0.35.0/src/boto3_assist/sqs/sqs_queue.py

@@ -0,0 +1,307 @@
+"""
+SQS Queue operations module.
+
+Geek Cafe, LLC
+Maintainers: Eric Wilson
+MIT License. See Project Root for the license information.
+"""
+
+import json
+from typing import Any, Dict, List, Optional
+
+from aws_lambda_powertools import Logger
+
+from boto3_assist.sqs.sqs_connection import SQSConnection
+
+logger = Logger(child=True)
+
+
+class SQSQueue(SQSConnection):
+    """SQS Queue operations wrapper."""
+
+    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:
+        """
+        Initialize SQS Queue.
+
+        Args:
+            aws_profile: AWS profile name
+            aws_region: AWS region
+            aws_end_point_url: Custom endpoint URL (for LocalStack, etc.)
+            aws_access_key_id: AWS access key ID
+            aws_secret_access_key: AWS secret access key
+        """
+        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,
+        )
+
+    def send_message(
+        self,
+        queue_url: str,
+        message_body: str,
+        delay_seconds: int = 0,
+        message_attributes: Optional[Dict[str, Any]] = None,
+        message_group_id: Optional[str] = None,
+        message_deduplication_id: Optional[str] = None,
+    ) -> str:
+        """
+        Send a message to an SQS queue.
+
+        Args:
+            queue_url: The URL of the SQS queue
+            message_body: The message body (string)
+            delay_seconds: Delay before message becomes visible (0-900 seconds)
+            message_attributes: Optional message attributes
+            message_group_id: Required for FIFO queues
+            message_deduplication_id: Required for FIFO queues without content-based deduplication
+
+        Returns:
+            The message ID of the sent message
+        """
+        params: Dict[str, Any] = {
+            "QueueUrl": queue_url,
+            "MessageBody": message_body,
+        }
+
+        if delay_seconds > 0:
+            params["DelaySeconds"] = min(delay_seconds, 900)  # SQS max is 900 seconds
+
+        if message_attributes:
+            params["MessageAttributes"] = message_attributes
+
+        if message_group_id:
+            params["MessageGroupId"] = message_group_id
+
+        if message_deduplication_id:
+            params["MessageDeduplicationId"] = message_deduplication_id
+
+        response = self.client.send_message(**params)
+        message_id = response.get("MessageId", "")
+
+        logger.debug(f"Sent message to {queue_url}: {message_id}")
+        return message_id
+
+    def send_message_batch(
+        self,
+        queue_url: str,
+        entries: List[Dict[str, Any]],
+    ) -> Dict[str, Any]:
+        """
+        Send multiple messages to an SQS queue in a batch.
+
+        Args:
+            queue_url: The URL of the SQS queue
+            entries: List of message entries, each with 'Id' and 'MessageBody'
+
+        Returns:
+            Response containing 'Successful' and 'Failed' lists
+        """
+        response = self.client.send_message_batch(
+            QueueUrl=queue_url,
+            Entries=entries,
+        )
+
+        successful = response.get("Successful", [])
+        failed = response.get("Failed", [])
+
+        if failed:
+            logger.warning(f"Failed to send {len(failed)} messages to {queue_url}")
+
+        logger.debug(f"Sent batch of {len(successful)} messages to {queue_url}")
+        return response
+
+    def receive_messages(
+        self,
+        queue_url: str,
+        max_number_of_messages: int = 1,
+        wait_time_seconds: int = 0,
+        visibility_timeout: Optional[int] = None,
+        message_attribute_names: Optional[List[str]] = None,
+    ) -> List[Dict[str, Any]]:
+        """
+        Receive messages from an SQS queue.
+
+        Args:
+            queue_url: The URL of the SQS queue
+            max_number_of_messages: Maximum number of messages to receive (1-10)
+            wait_time_seconds: Long polling wait time (0-20 seconds)
+            visibility_timeout: Override the queue's default visibility timeout
+            message_attribute_names: List of message attribute names to retrieve
+
+        Returns:
+            List of messages
+        """
+        params: Dict[str, Any] = {
+            "QueueUrl": queue_url,
+            "MaxNumberOfMessages": min(max_number_of_messages, 10),
+            "WaitTimeSeconds": min(wait_time_seconds, 20),
+        }
+
+        if visibility_timeout is not None:
+            params["VisibilityTimeout"] = visibility_timeout
+
+        if message_attribute_names:
+            params["MessageAttributeNames"] = message_attribute_names
+
+        response = self.client.receive_message(**params)
+        messages = response.get("Messages", [])
+
+        logger.debug(f"Received {len(messages)} messages from {queue_url}")
+        return messages
+
+    def delete_message(
+        self,
+        queue_url: str,
+        receipt_handle: str,
+    ) -> None:
+        """
+        Delete a message from an SQS queue.
+
+        Args:
+            queue_url: The URL of the SQS queue
+            receipt_handle: The receipt handle of the message to delete
+        """
+        self.client.delete_message(
+            QueueUrl=queue_url,
+            ReceiptHandle=receipt_handle,
+        )
+        logger.debug(f"Deleted message from {queue_url}")
+
+    def delete_message_batch(
+        self,
+        queue_url: str,
+        entries: List[Dict[str, str]],
+    ) -> Dict[str, Any]:
+        """
+        Delete multiple messages from an SQS queue in a batch.
+
+        Args:
+            queue_url: The URL of the SQS queue
+            entries: List of entries with 'Id' and 'ReceiptHandle'
+
+        Returns:
+            Response containing 'Successful' and 'Failed' lists
+        """
+        response = self.client.delete_message_batch(
+            QueueUrl=queue_url,
+            Entries=entries,
+        )
+
+        logger.debug(f"Deleted batch of messages from {queue_url}")
+        return response
+
+    def get_queue_url(self, queue_name: str) -> str:
+        """
+        Get the URL of an SQS queue by name.
+
+        Args:
+            queue_name: The name of the queue
+
+        Returns:
+            The queue URL
+        """
+        response = self.client.get_queue_url(QueueName=queue_name)
+        return response["QueueUrl"]
+
+    def get_queue_attributes(
+        self,
+        queue_url: str,
+        attribute_names: Optional[List[str]] = None,
+    ) -> Dict[str, str]:
+        """
+        Get attributes of an SQS queue.
+
+        Args:
+            queue_url: The URL of the SQS queue
+            attribute_names: List of attribute names to retrieve (default: All)
+
+        Returns:
+            Dictionary of queue attributes
+        """
+        params: Dict[str, Any] = {"QueueUrl": queue_url}
+
+        if attribute_names:
+            params["AttributeNames"] = attribute_names
+        else:
+            params["AttributeNames"] = ["All"]
+
+        response = self.client.get_queue_attributes(**params)
+        return response.get("Attributes", {})
+
+    def purge_queue(self, queue_url: str) -> None:
+        """
+        Purge all messages from an SQS queue.
+
+        Args:
+            queue_url: The URL of the SQS queue
+
+        Note: This action can only be performed once every 60 seconds.
+        """
+        self.client.purge_queue(QueueUrl=queue_url)
+        logger.info(f"Purged queue: {queue_url}")
+
+    def change_message_visibility(
+        self,
+        queue_url: str,
+        receipt_handle: str,
+        visibility_timeout: int,
+    ) -> None:
+        """
+        Change the visibility timeout of a message.
+
+        Args:
+            queue_url: The URL of the SQS queue
+            receipt_handle: The receipt handle of the message
+            visibility_timeout: New visibility timeout in seconds (0-43200)
+        """
+        self.client.change_message_visibility(
+            QueueUrl=queue_url,
+            ReceiptHandle=receipt_handle,
+            VisibilityTimeout=visibility_timeout,
+        )
+        logger.debug(f"Changed visibility timeout for message in {queue_url}")
+
+    def send_json_message(
+        self,
+        queue_url: str,
+        message: Dict[str, Any],
+        delay_seconds: int = 0,
+        message_attributes: Optional[Dict[str, Any]] = None,
+        message_group_id: Optional[str] = None,
+        message_deduplication_id: Optional[str] = None,
+    ) -> str:
+        """
+        Send a JSON message to an SQS queue.
+
+        Convenience method that serializes a dict to JSON.
+
+        Args:
+            queue_url: The URL of the SQS queue
+            message: Dictionary to serialize and send
+            delay_seconds: Delay before message becomes visible
+            message_attributes: Optional message attributes
+            message_group_id: Required for FIFO queues
+            message_deduplication_id: Required for FIFO queues
+
+        Returns:
+            The message ID of the sent message
+        """
+        return self.send_message(
+            queue_url=queue_url,
+            message_body=json.dumps(message),
+            delay_seconds=delay_seconds,
+            message_attributes=message_attributes,
+            message_group_id=message_group_id,
+            message_deduplication_id=message_deduplication_id,
+        )

boto3_assist-0.35.0/src/boto3_assist/version.py

@@ -0,0 +1 @@
+__version__ = "0.35.0"

boto3_assist-0.35.0/tests/unit/utilities/case_transformation/files/user_import.json

@@ -0,0 +1,125 @@
+[
+    {
+        "id": "1765833213-933783:e9fef866-d9fa-11f0-8000-000000000000",
+        "created_by_id": "user_123",
+        "updated_by_id": "user_123",
+        "deleted_by_id": null,
+        "version": 1.0,
+        "tenant_id": "tenant_123",
+        "uploaded_by_id": null,
+        "bucket": "test-destination-bucket",
+        "category": "user_import",
+        "checksum": null,
+        "content_type": "text/csv",
+        "created_utc": "2025-12-15T21:13:33.933805+00:00",
+        "created_utc_ts": 1765833213.933805,
+        "deleted_utc": null,
+        "deleted_utc_ts": null,
+        "description": null,
+        "directory_id": null,
+        "errors": null,
+        "extension": ".csv",
+        "is_hidden": false,
+        "key": "tenants/tenant_123/users/user_123/files/1765833213-933783:e9fef866-d9fa-11f0-8000-000000000000/path/input.csv",
+        "lineage": "original",
+        "metadata": {
+            "converter": {
+                "version": "0.14.0",
+                "timestamp": "2025-12-15T16:13:34.362980",
+                "name": "input-file-converter"
+            },
+            "user_import": "conversion-required",
+            "converted_status": "completed",
+            "converted_file_id": "39e2c7e9-61c8-4d8b-81bc-b8d717cc99c7",
+            "converted_file_name": "input-csv-converted.csv",
+            "converted_reason": "cp1252"
+        },
+        "mime_type": "text/csv",
+        "model_name": "file",
+        "model_name_plural": "files",
+        "model_version": "1.0.0",
+        "modified_utc": "2025-12-15T21:13:34.365121+00:00",
+        "modified_utc_ts": 1765833214.365121,
+        "name": "input.csv",
+        "owner_id": "user_123",
+        "parent_id": null,
+        "retention_policy": "permanent",
+        "root_id": "1765833213-933783:e9fef866-d9fa-11f0-8000-000000000000",
+        "size": 0,
+        "state": "ready",
+        "status": "active",
+        "table_name": null,
+        "uploaded_utc": null,
+        "uploaded_utc_ts": null,
+        "user_id": "user_123",
+        "version_id": "1765833213-933783:e9fef866-d9fa-11f0-8000-000000000000",
+        "version_ts_utc": 1765833213.933805,
+        "virtual_path": "/input.csv",
+        "visibility": "private"
+    },
+    {
+        "id": "39e2c7e9-61c8-4d8b-81bc-b8d717cc99c7",
+        "created_by_id": "user_123",
+        "updated_by_id": "user_123",
+        "deleted_by_id": null,
+        "version": 1.0,
+        "tenant_id": "tenant_123",
+        "uploaded_by_id": null,
+        "bucket": "test-destination-bucket",
+        "category": "user_import",
+        "checksum": null,
+        "content_type": null,
+        "created_utc": "2025-12-15T21:13:34.344200+00:00",
+        "created_utc_ts": 1765833214.3442,
+        "deleted_utc": null,
+        "deleted_utc_ts": null,
+        "description": null,
+        "directory_id": null,
+        "errors": null,
+        "extension": ".csv",
+        "is_hidden": false,
+        "key": "tenants/tenant_123/users/user_123/files/39e2c7e9-61c8-4d8b-81bc-b8d717cc99c7/path/input-csv-converted.csv",
+        "lineage": "derived",
+        "metadata": {
+            "transformation": {
+                "type": "converted",
+                "operation": "cp1252_to_csv"
+            },
+            "user_import": "approved",
+            "column_names": [
+                "id",
+                "time",
+                "first_name",
+                "last_name",
+                "email"
+            ],
+            "converter": {
+                "version": "0.14.0",
+                "timestamp": "2025-12-15T16:13:34.342777",
+                "name": "analysis-input-file-converter"
+            }
+        },
+        "mime_type": null,
+        "model_name": "file",
+        "model_name_plural": "files",
+        "model_version": "3.0.0",
+        "modified_utc": "2025-12-15T21:13:34.344220+00:00",
+        "modified_utc_ts": 1765833214.34422,
+        "name": "input-csv-converted.csv",
+        "owner_id": "user_123",
+        "parent_id": "1765833213-933783:e9fef866-d9fa-11f0-8000-000000000000",
+        "retention_policy": "permanent",
+        "root_id": "1765833213-933783:e9fef866-d9fa-11f0-8000-000000000000",
+        "size": 0,
+        "state": "ready",
+        "status": "active",
+        "table_name": null,
+        "uploaded_utc": null,
+        "uploaded_utc_ts": null,
+        "user_id": "user_123",
+        "version_id": "39e2c7e9-61c8-4d8b-81bc-b8d717cc99c7",
+        "version_ts_utc": 1765833214.3442,
+        "virtual_path": "/input-csv-converted.csv",
+        "visibility": "private"
+    }
+]

boto3_assist-0.35.0/tests/unit/utilities/case_transformation/test_case_transformation.py

@@ -0,0 +1,129 @@
+"""Unit tests for case transformation utilities."""
+
+import json
+import os
+from pathlib import Path
+
+import pytest
+
+from boto3_assist.utilities.string_utility import StringUtility
+
+
+class TestCaseTransformation:
+    """Tests for snake_case to camelCase conversion."""
+
+    @pytest.fixture
+    def files_dir(self) -> Path:
+        """Return the path to the files subdirectory."""
+        return Path(__file__).parent / "files"
+
+    @pytest.fixture
+    def output_dir(self) -> Path:
+        """Return the path to the .output directory, creating it if needed."""
+        output_path = Path(__file__).parent / ".output"
+        output_path.mkdir(exist_ok=True)
+        return output_path
+
+    def convert_keys_to_camel_case(self, obj):
+        """Recursively convert all dictionary keys from snake_case to camelCase."""
+        if isinstance(obj, dict):
+            return {
+                StringUtility.snake_to_camel(key): self.convert_keys_to_camel_case(
+                    value
+                )
+                for key, value in obj.items()
+            }
+        elif isinstance(obj, list):
+            return [self.convert_keys_to_camel_case(item) for item in obj]
+        else:
+            return obj
+
+    def test_snake_to_camel_basic(self):
+        """Test basic snake_case to camelCase conversion."""
+        assert StringUtility.snake_to_camel("hello_world") == "helloWorld"
+        assert StringUtility.snake_to_camel("created_by_id") == "createdById"
+        assert StringUtility.snake_to_camel("tenant_id") == "tenantId"
+        assert StringUtility.snake_to_camel("single") == "single"
+
+    def test_convert_files_to_camel_case(self, files_dir: Path, output_dir: Path):
+        """
+        Loop through all JSON files in the files subdirectory,
+        convert keys from snake_case to camelCase, and write output
+        to the .output directory for visual inspection.
+        """
+        json_files = list(files_dir.glob("*.json"))
+        assert len(json_files) > 0, "No JSON files found in files directory"
+
+        for json_file in json_files:
+            # Read the input file
+            with open(json_file, "r", encoding="utf-8") as f:
+                data = json.load(f)
+
+            # Convert all keys from snake_case to camelCase
+            converted_data = self.convert_keys_to_camel_case(data)
+
+            # Write to output directory with same filename
+            output_file = output_dir / json_file.name
+            with open(output_file, "w", encoding="utf-8") as f:
+                json.dump(converted_data, f, indent=4)
+
+            # Verify the output file was created
+            assert output_file.exists(), f"Output file {output_file} was not created"
+
+            # Verify some key conversions occurred
+            if isinstance(converted_data, list) and len(converted_data) > 0:
+                first_item = converted_data[0]
+                # Check that snake_case keys were converted
+                assert (
+                    "createdById" in first_item
+                ), "Expected 'createdById' key after conversion"
+                assert (
+                    "tenantId" in first_item
+                ), "Expected 'tenantId' key after conversion"
+                assert (
+                    "created_by_id" not in first_item
+                ), "Key 'created_by_id' should have been converted"
+
+            print(f"Converted {json_file.name} -> {output_file}")
+
+    def test_nested_conversion(self, files_dir: Path, output_dir: Path):
+        """Test that nested dictionaries are also converted."""
+        json_files = list(files_dir.glob("*.json"))
+
+        for json_file in json_files:
+            with open(json_file, "r", encoding="utf-8") as f:
+                data = json.load(f)
+
+            converted_data = self.convert_keys_to_camel_case(data)
+
+            # Check nested metadata conversion
+            if isinstance(converted_data, list):
+                for item in converted_data:
+                    if "metadata" in item and isinstance(item["metadata"], dict):
+                        metadata = item["metadata"]
+                        # Verify nested keys are converted
+                        if "converter" in metadata:
+                            converter = metadata["converter"]
+                            # Keys inside nested dicts should also be camelCase
+                            assert "version" in converter or "timestamp" in converter
+                        if "columnNames" in metadata:
+                            # This was column_names in original
+                            assert isinstance(metadata["columnNames"], list)
+
+    def test_all_files_processed(self, files_dir: Path, output_dir: Path):
+        """Verify all files in the files directory are processed."""
+        json_files = list(files_dir.glob("*.json"))
+
+        for json_file in json_files:
+            with open(json_file, "r", encoding="utf-8") as f:
+                data = json.load(f)
+
+            converted_data = self.convert_keys_to_camel_case(data)
+            output_file = output_dir / json_file.name
+
+            with open(output_file, "w", encoding="utf-8") as f:
+                json.dump(converted_data, f, indent=4)
+
+        # Verify output count matches input count
+        output_files = list(output_dir.glob("*.json"))
+        assert len(output_files) >= len(json_files), "Not all files were converted"