boto3-assist 0.27.0__tar.gz → 0.28.0__tar.gz

{boto3_assist-0.27.0 → boto3_assist-0.28.0}/.gitignore

@@ -170,3 +170,5 @@ cython_debug/
 .pysetup.json
 
 activate.sh
+.pypirc
+.DS_Store

{boto3_assist-0.27.0 → boto3_assist-0.28.0}/PKG-INFO

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

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

{boto3_assist-0.27.0 → boto3_assist-0.28.0}/src/boto3_assist/utilities/serialization_utility.py

@@ -8,6 +8,7 @@ import datetime as dt
 import decimal
 import inspect
 import json
+import typing
 import uuid
 from datetime import datetime
 from decimal import Decimal
@@ -116,6 +117,86 @@ class JsonConversions:
     Used for snake_case to camelCase and vice versa
     """
 
+    @staticmethod
+    def string_to_json_obj(
+        value: str | list | dict, raise_on_error: bool = True, retry: int = 0
+    ) -> typing.Union[dict, typing.Any, None]:
+        """
+        Converts a string to a JSON object.
+
+        Args:
+            value: The value to convert (string, list, or dict).
+            raise_on_error: Whether to raise an exception on error.
+            retry: The number of retry attempts made.
+
+        Returns:
+            The converted JSON object, or the original value if conversion fails.
+        """
+        # Handle empty/None values
+        if not value:
+            return {}
+
+        # Return dicts unchanged
+        if isinstance(value, dict):
+            return value
+
+        # Check retry limit early
+        if retry > 5:
+            raise RuntimeError("Too many attempts to convert string to JSON")
+
+        try:
+            # Convert to string if needed
+            if not isinstance(value, str):
+                value = str(value)
+
+            # Clean up the string
+            value = value.replace("\n", "").strip()
+            if value.startswith("'") and value.endswith("'"):
+                value = value.strip("'").strip()
+
+            # Parse JSON
+            parsed_value = json.loads(value)
+            
+            # Handle nested string JSON (recursive case)
+            if isinstance(parsed_value, str):
+                return JsonConversions.string_to_json_obj(parsed_value, raise_on_error, retry + 1)
+            
+            return parsed_value
+
+        except json.JSONDecodeError as e:
+            # Try to fix malformed JSON with single quotes
+            if "Expecting property name enclosed in double quotes" in str(e) and retry < 5:
+                if isinstance(value, str):
+                    fixed_json = JsonConversions.convert_bad_json_string(value)
+                    return JsonConversions.string_to_json_obj(fixed_json, raise_on_error, retry + 1)
+            
+            if raise_on_error:
+                raise e
+            return {}
+
+        except Exception as e:
+            if raise_on_error:
+                logger.exception({"source": "string_to_json_obj", "error": str(e), "value": value})
+                raise e
+            
+            logger.warning({"source": "string_to_json_obj", "returning_original": True, "value": value})
+            return value
+
+
+    @staticmethod
+    def convert_bad_json_string(bad_json: str) -> str:
+        """
+        Fixes malformed JSON by converting single quotes to double quotes.
+
+        Args:
+            bad_json: Malformed JSON string with single quotes.
+
+        Returns:
+            Fixed JSON string with proper double quotes.
+        """
+        # Use a placeholder to safely swap quotes
+        return bad_json.replace("'", "§§§").replace('"', "'").replace("§§§", '"')
+
     @staticmethod
     def _camel_to_snake(value: str) -> str:
         """Converts a camelCase to a snake_case"""

boto3_assist-0.28.0/src/boto3_assist/version.py

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

{boto3_assist-0.27.0 → boto3_assist-0.28.0}/tests/unit/utilities/serialization_utility_test.py

@@ -5,11 +5,12 @@ MIT License.  See Project Root for the license information.
 """
 
 import unittest
+import json
 from datetime import datetime, UTC
 from datetime import timedelta
 from typing import cast
 from typing import Optional, List
-from boto3_assist.utilities.serialization_utility import Serialization
+from boto3_assist.utilities.serialization_utility import Serialization, JsonConversions
 from boto3_assist.dynamodb.dynamodb_model_base import (
     DynamoDBModelBase,
     exclude_indexes_from_serialization,
@@ -264,3 +265,147 @@ class SerializationUnitTest(unittest.TestCase):
         self.assertIsNone(active_subscription.get("sk"))
         self.assertIsNone(active_subscription.get("gsi0_pk"))
         self.assertIsNone(active_subscription.get("gsi0_sk"))
+
+
+class JsonConversionsUnitTest(unittest.TestCase):
+    """Unit tests for JsonConversions.string_to_json_obj function"""
+
+    def setUp(self):
+        """Set up common test data"""
+        self.sample_dict = {"name": "John", "age": 30}
+        self.sample_json = '{"name": "John", "age": 30}'
+
+    def test_valid_json_conversions(self):
+        """Test converting valid JSON strings and data types"""
+        test_cases = [
+            (
+                '{"name": "John", "age": 30, "active": true}',
+                {"name": "John", "age": 30, "active": True},
+            ),
+            (
+                '[{"name": "John"}, {"name": "Jane"}]',
+                [{"name": "John"}, {"name": "Jane"}],
+            ),
+            (
+                '{"message": "Hello 🌍", "symbol": "©"}',
+                {"message": "Hello 🌍", "symbol": "©"},
+            ),
+            (
+                '{"name": "John", "middle_name": null}',
+                {"name": "John", "middle_name": None},
+            ),
+        ]
+
+        for json_input, expected in test_cases:
+            with self.subTest(json_input=json_input):
+                result = JsonConversions.string_to_json_obj(json_input)
+                self.assertEqual(result, expected)
+
+    def test_empty_and_none_inputs(self):
+        """Test edge cases with empty/None inputs"""
+        test_cases = [
+            ("", {}),
+            (None, {}),
+        ]
+
+        for input_val, expected in test_cases:
+            with self.subTest(input_val=input_val):
+                result = JsonConversions.string_to_json_obj(input_val)
+                self.assertEqual(result, expected)
+
+    def test_passthrough_types(self):
+        """Test that certain types pass through unchanged"""
+        input_dict = {"name": "John", "age": 30}
+        result = JsonConversions.string_to_json_obj(input_dict)
+        self.assertEqual(result, input_dict)
+        self.assertIs(result, input_dict)
+
+    def test_string_preprocessing(self):
+        """Test string preprocessing (whitespace, quotes)"""
+        test_cases = [
+            ('\n  {"name": "John", "age": 30}  \n', self.sample_dict),
+            ('\'{"name": "John", "age": 30}\'', self.sample_dict),
+            ('"{\\"name\\": \\"John\\", \\"age\\": 30}"', self.sample_dict),
+        ]
+
+        for json_input, expected in test_cases:
+            with self.subTest(json_input=json_input[:20] + "..."):
+                result = JsonConversions.string_to_json_obj(json_input)
+                self.assertEqual(result, expected)
+
+    def test_malformed_json_auto_fix(self):
+        """Test auto-fixing of malformed JSON"""
+        bad_json = "{'name': 'John', 'age': 30}"
+        result = JsonConversions.string_to_json_obj(bad_json)
+        self.assertEqual(result, self.sample_dict)
+
+    def test_error_handling_with_raise_on_error_true(self):
+        """Test error handling when raise_on_error=True"""
+        test_cases = [
+            ("{'name': 'John', 'age': 30, 'invalid'}", json.JSONDecodeError),
+            ('{"valid": "json"}', RuntimeError),  # retry=10 triggers RuntimeError
+        ]
+
+        for invalid_input, expected_exception in test_cases:
+            with self.subTest(invalid_input=invalid_input):
+                with self.assertRaises(expected_exception):
+                    if expected_exception == RuntimeError:
+                        JsonConversions.string_to_json_obj(invalid_input, retry=10)
+                    else:
+                        JsonConversions.string_to_json_obj(
+                            invalid_input, raise_on_error=True
+                        )
+
+    def test_error_handling_with_raise_on_error_false(self):
+        """Test graceful error handling when raise_on_error=False"""
+        test_cases = [
+            ("{'name': 'John', 'age': 30, 'invalid'}", {}),
+            (12345, 12345),  # Non-string input
+        ]
+
+        for invalid_input, expected in test_cases:
+            with self.subTest(invalid_input=invalid_input):
+                result = JsonConversions.string_to_json_obj(
+                    invalid_input, raise_on_error=False
+                )
+                self.assertEqual(result, expected)
+
+    def test_retry_limit(self):
+        """Test retry limit enforcement"""
+        with self.assertRaises(RuntimeError) as context:
+            JsonConversions.string_to_json_obj(self.sample_json, retry=6)
+        self.assertIn("Too many attempts", str(context.exception))
+
+    def test_complex_nested_structure(self):
+        """Test complex nested JSON structure"""
+        complex_json = """{
+            "user": {"name": "John Doe", "details": {"age": 30, "preferences": ["reading", "coding"]}},
+            "metadata": {"version": 1.2}
+        }"""
+
+        result = JsonConversions.string_to_json_obj(complex_json)
+
+        # Verify key nested values
+        self.assertEqual(result["user"]["name"], "John Doe")
+        self.assertEqual(result["user"]["details"]["age"], 30)
+        self.assertEqual(
+            result["user"]["details"]["preferences"], ["reading", "coding"]
+        )
+        self.assertEqual(result["metadata"]["version"], 1.2)
+
+    def test_data_type_preservation(self):
+        """Test that JSON data types are properly preserved"""
+        json_with_types = """{
+            "string_val": "text", "int_val": 42, "float_val": 3.14,
+            "bool_true": true, "bool_false": false, "null_val": null
+        }"""
+
+        result = JsonConversions.string_to_json_obj(json_with_types)
+
+        # Verify all data types
+        self.assertEqual(result["string_val"], "text")
+        self.assertEqual(result["int_val"], 42)
+        self.assertEqual(result["float_val"], 3.14)
+        self.assertTrue(result["bool_true"])
+        self.assertFalse(result["bool_false"])
+        self.assertIsNone(result["null_val"])

{boto3_assist-0.27.0 → boto3_assist-0.28.0}/tests/unit/utilities/string_utility_test.py

@@ -17,7 +17,7 @@ class StringUtilityUnitTest(unittest.TestCase):
     "String Utility Tests"
 
     def test_uuid_idempotency(self):
-        """Testing Idempotnent UUID generation."""
+        """Testing Idempotent UUID generation."""
         # must be consistent
         namespace: uuid.UUID = uuid.UUID("6ba7b810-9dad-11d1-80b4-00c04fd430c8")
 

boto3_assist-0.27.0/.pypirc

@@ -1,13 +0,0 @@
-[distutils]
-index-servers =
-    pypi
-    testpypi
-
-[pypi]
-username = __token__
-password = pypi-AgEIcHlwaS5vcmcCJGE0NDBkMmNlLWIzMWUtNDRjZC1iOGQxLTdiYmIzYmZkNWE0NAACKlszLCI3YzZmZTIzYS04MDVkLTQ0YjYtODlkZS04YTJiODJiNjBmMDQiXQAABiA_5UuF03-RSqW69zwSeC9I5rR8EIR4uZ8Zcj9p73XCXA
-
-[testpypi]
-repository = https://test.pypi.org/legacy/
-username = __token__
-password = pypi-AgENdGVzdC5weXBpLm9yZwIkZmEwOTVlMTAtMzE5ZC00MjU5LTk2ZjUtNjkzODg4MWIxMjE4AAIqWzMsImE3YzE2NzI0LTZjYmQtNDQzZi1iYzYyLTNhM2I3NWI4NDg5OSJdAAAGIGQlPqWLM1ziye_G9C1kLOG47bBEAAxTQmnnpaimREd1

boto3_assist-0.27.0/src/boto3_assist/version.py

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