Merge dev into main

Author: DinisCruz

README.md

@@ -1,6 +1,6 @@
 # OSBot-Utils
 
-![Current Release](https://img.shields.io/badge/release-v3.26.0-blue)
+![Current Release](https://img.shields.io/badge/release-v3.26.1-blue)
 ![Python](https://img.shields.io/badge/python-3.8+-green)
 ![Type-Safe](https://img.shields.io/badge/Type--Safe-✓-brightgreen)
 ![Caching](https://img.shields.io/badge/Caching-Built--In-orange)

osbot_utils/type_safe/type_safe_core/collections/Type_Safe__Dict.py

@@ -41,23 +41,32 @@ def __setitem__(self, key, value):                                          # Ch
     def __enter__(self): return self
     def __exit__ (self, type, value, traceback): pass
 
-    def json(self):
-        from osbot_utils.type_safe.Type_Safe import Type_Safe
+    # todo: this method needs to be refactored into smaller parts, it is getting to complex:
+    #         the use of the inner method serialize_value
+    #         the circular dependency on Type_Safe
+    #         the inner for loops to handle nested dictionaries
+    #         the enum edges cases (like the nested dictionaries case)
+    #         .
+    #         good news is that we have tons of tests and edge cases detection (so we should be able to do this
+    #         refactoring with no side effects
+    def json(self):                                                                     # Recursively serialize values, handling nested structures
+        from osbot_utils.type_safe.Type_Safe import Type_Safe                           # needed here due to circular dependencies
 
         def serialize_value(v):
-            """Recursively serialize values, handling nested structures"""
             if isinstance(v, Type_Safe):
                 return v.json()
             elif isinstance(v, Type_Safe__Primitive):
                 return v.__to_primitive__()
             elif isinstance(v, type):
                 return class_full_name(v)
             elif isinstance(v, dict):
-                # Recursively handle nested dictionaries
-                return {k2: serialize_value(v2) for k2, v2 in v.items()}
+                return {                                                                            # Recursively handle nested dictionaries (with enum support)
+                            (k2.value if isinstance(k2, Enum) else k2): serialize_value(v2)
+                            for k2, v2 in v.items()
+                        }
+                #return {k2: serialize_value(v2) for k2, v2 in v.items()}                            # Recursively handle nested dictionaries
             elif isinstance(v, (list, tuple, set, frozenset)):
-                # Recursively handle sequences
-                serialized = [serialize_value(item) for item in v]
+                serialized = [serialize_value(item) for item in v]                                  # Recursively handle sequences
                 if isinstance(v, list):
                     return serialized
                 elif isinstance(v, tuple):
@@ -95,4 +104,4 @@ def obj(self) -> __:
         return dict_to_obj(self.json())
 
     def values(self) -> Type_Safe__List:
-        return Type_Safe__List(self.expected_value_type, super().values())
+        return Type_Safe__List(self.expected_value_type, super().values())

osbot_utils/version

@@ -1 +1 @@
-v3.26.0
+v3.26.1

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name        = "osbot_utils"
-version     = "v3.26.0"
+version     = "v3.26.1"
 description = "OWASP Security Bot - Utils"
 authors     = ["Dinis Cruz <[email protected]>"]
 license     = "MIT"

tests/unit/type_safe/type_safe_core/_bugs/test_Type_Safe__Dict__bugs.py

@@ -6,8 +6,6 @@
 
 class test_Type_Safe__Dict__bugs(TestCase):
 
-
-
     def test__bug__type_safe_list_with_dict_any_type__and__error_message_is_confusing(self):   # Document bug where Dict[str, any] fails in List ,and the error message doesn't mention that Any works
 
         class Schema__Order__Bug(Type_Safe):

tests/unit/type_safe/type_safe_core/_regression/test_Type_Safe__Dict__regression.py

@@ -1,3 +1,5 @@
+import json
+import re
 import pytest
 from enum                                                                           import Enum
 from unittest                                                                       import TestCase
@@ -10,6 +12,7 @@
 from osbot_utils.type_safe.primitives.domains.identifiers.safe_str.Safe_Str__Id     import Safe_Str__Id
 from osbot_utils.type_safe.type_safe_core.collections.Type_Safe__Dict               import Type_Safe__Dict
 from osbot_utils.type_safe.type_safe_core.collections.Type_Safe__List               import Type_Safe__List
+from osbot_utils.utils.Env import not_in_github_action
 from osbot_utils.utils.Objects                                                      import base_classes
 from osbot_utils.type_safe.primitives.domains.identifiers.Safe_Id                   import Safe_Id
 from osbot_utils.type_safe.Type_Safe                                                import Type_Safe
@@ -380,4 +383,81 @@ class An_Class(Type_Safe):
         assert An_Class(an_dict={'A': 42}).json() ==   { 'an_dict': {  'A': 42}}        # FIXED
         assert An_Class.from_json(An_Class(an_dict={'A': 42}).json()).obj() == __(an_dict=__(A=42))            # FIXED
         assert An_Class.from_json({ 'an_dict': {  An_Enum.A: 42}}   ).obj() == __(an_dict=__(A=42))            #
-        assert An_Class.from_json({ 'an_dict': {  'A'      : 42}}   ).obj() == __(an_dict=__(A=42))            #
+        assert An_Class.from_json({ 'an_dict': {  'A'      : 42}}   ).obj() == __(an_dict=__(A=42))            #
+
+    def test__regression__nested_dict_enum_keys__obj_vs_json_inconsistency(self):
+        """
+        BUG: .obj() and .json() are inconsistent for nested Dict with Enum keys.
+        .json() uses enum.value, .obj() uses transformed enum.name
+        """
+        class Status(str, Enum):
+            ACTIVE   = 'active'
+            INACTIVE = 'inactive'
+
+        class Container(Type_Safe):
+            nested: Dict[str, Dict[Status, int]]
+
+        container = Container(nested={'key': {Status.ACTIVE: 100}})
+
+        # .json() uses enum VALUE
+        assert container.json() == {'nested': {'key': {'active': 100}}}
+
+        # BUG: .obj() should also use 'active' but uses 'Status_ACTIVE'
+        #assert container.obj() == __(nested=__(key=__(Status_ACTIVE=100)))  # BUG Current behavior
+        #assert container.obj() != __(nested=__(key=__(active=100)))         # BUG Expected behavior
+        assert container.obj() == __(nested=__(key=__(active=100)))          # FIXED
+
+        # assert container.json() == {'nested': {'key': {Status.ACTIVE: 100}}}                                  # BUG
+        # error_message = ("assert {'nested': {'key': {<Status.ACTIVE: 'active'>: 100}}} == {}\n  \n  "
+        #                  "Left contains 1 more item:\n  "
+        #                  "{'nested': {'key': {<Status.ACTIVE: 'active'>: 100}}}\n  \n  "
+        #                  "Full diff:\n  - {}\n  + {\n  +     'nested': {\n  +         'key': "
+        #                  "{\n  +             <Status.ACTIVE: 'active'>: 100,\n  +         },\n  +     "
+        #                  "},\n  + }")                                                                          # BUG
+        assert container.json() == {'nested': {'key': {Status.ACTIVE: 100}}}                # this works due to auto conversion of enum into it's string value
+        assert container.json() == {'nested': {'key': {'active': 100}}}                     # FIXED: this is what we wanted to happen
+
+        if not_in_github_action():                                                              # GH actions has different spacing
+            error_message = ("assert {'nested': {'key': {'active': 100}}} == {}\n  \n  "
+                             "Left contains 1 more item:\n  "
+                             "{'nested': {'key': {'active': 100}}}\n  \n  "                     # FIXED: now we get the 'active' string (instead of the Enum representation)
+                             "Full diff:\n  - {}\n  + {\n  +     'nested': "
+                             "{\n  +         'key': {\n  +             "
+                             "'active': 100,\n  +         },\n  +     },\n  + }")
+            with pytest.raises(AssertionError, match=re.escape(error_message)):
+                assert container.json() == {}                                                   # FIXED this is the error message we should get
+
+            error_message_2 = 'assert __(nested=__(key=__(active=100))) == __()\n '
+            with pytest.raises(AssertionError, match=re.escape(error_message_2)):
+                assert container.obj() == __()
+
+        # couple more edge cases tests
+        json_str = json.dumps(container.json())
+        assert json_str == '{"nested": {"key": {"active": 100}}}'
+        assert json.loads(json_str) == {'nested': {'key': {'active': 100}}}
+
+        container2 = Container(nested={'key': {Status.ACTIVE: 100, Status.INACTIVE: 50}})
+        assert container2.json() == {'nested': {'key': {'active': 100, 'inactive': 50}}}
+        assert container2.obj() == __(nested=__(key=__(active=100, inactive=50)))
+
+        # Test round-trip consistency
+        container3 = Container.from_json(container.json())
+        assert container3.json() == container.json()
+        assert container3.obj()  == container.obj()
+
+    def test__regression__simple_dict_enum_keys__now__works_correctly(self):
+
+        class Status(str, Enum):
+            ACTIVE   = 'active'
+            INACTIVE = 'inactive'
+
+        class SimpleContainer(Type_Safe):
+            data: Dict[Status, int]
+
+        simple = SimpleContainer(data={Status.ACTIVE: 100})
+
+        # Single-level Dict works correctly - uses enum value
+        assert simple.json() == {'data': {'active': 100}}  # ✓ Correct
+
+        # And it's JSON-serializable
+        assert json.dumps(simple.json()) == '{"data": {"active": 100}}'  # ✓ Works