major fix to the .obj() testing helper, where now it creates valid python identifiers :)

refactored .obj() related methods into a new class called __helpers()
added new Safe_Str__Python__Identifier (which is used by .obj() to create the safe identifier name)
added tests for test_Safe_Str__Python__Identifier and test_Safe_Str__Python__Module (which were missing)
fixed ton of references that broke since the import of __ from the Objects class was quite widely used

Author: DinisCruz

osbot_utils/decorators/methods/required_fields.py

@@ -1,5 +1,4 @@
-from functools import wraps
-
+from functools                 import wraps
 from osbot_utils.utils.Objects import get_missing_fields
 
 

osbot_utils/helpers/ast/nodes/Ast_Call.py

@@ -1,4 +1,3 @@
-from osbot_utils.utils.Objects import obj_info
 from osbot_utils.helpers.ast.Ast_Node import Ast_Node
 
 class Ast_Call(Ast_Node):

osbot_utils/helpers/cache_requests/Cache__Requests__Data.py

@@ -1,5 +1,5 @@
 import types
-from osbot_utils.type_safe.Type_Safe                                     import Type_Safe
+from osbot_utils.type_safe.Type_Safe                                        import Type_Safe
 from osbot_utils.helpers.cache_requests.Cache__Requests__Config             import Cache__Requests__Config
 from osbot_utils.helpers.cache_requests.Cache__Requests__Table              import Cache__Requests__Table
 from osbot_utils.utils.Json                                                 import json_dumps, json_loads

osbot_utils/helpers/sqlite/tables/Sqlite__Table__Config.py

@@ -1,7 +1,7 @@
-from osbot_utils.base_classes.Kwargs_To_Self    import Kwargs_To_Self
+from osbot_utils.base_classes.Kwargs_To_Self      import Kwargs_To_Self
 from osbot_utils.decorators.methods.cache_on_self import cache_on_self
-from osbot_utils.helpers.sqlite.Sqlite__Table   import Sqlite__Table
-from osbot_utils.utils.Objects                  import pickle_save_to_bytes, pickle_load_from_bytes
+from osbot_utils.helpers.sqlite.Sqlite__Table     import Sqlite__Table
+from osbot_utils.utils.Objects                    import pickle_save_to_bytes, pickle_load_from_bytes
 
 SQLITE__TABLE_NAME__CONFIG = 'config'
 

osbot_utils/testing/__.py

@@ -5,8 +5,6 @@
 __MISSING__ = object()
 
 
-
-
 class __(SimpleNamespace):
     def __enter__(self)                          : return self
     def __exit__(self, exc_type, exc_val, exc_tb): return False
@@ -19,7 +17,7 @@ def __eq__(self, other):
             return super().__eq__(other)
 
         for key in set(self.__dict__.keys()) | set(other.__dict__.keys()):
-            self_val = getattr(self, key, None)
+            self_val  = getattr(self, key, None)
             other_val = getattr(other, key, None)
 
             if self_val is __SKIP__ or other_val is __SKIP__:                              # Skip comparison if either value is a skip marker

osbot_utils/testing/__helpers.py

@@ -0,0 +1,39 @@
+import json
+from types                                                                                      import SimpleNamespace
+from osbot_utils.testing.__                                                                     import __
+from collections.abc                                                                            import Mapping
+from osbot_utils.type_safe.primitives.domains.identifiers.safe_str.Safe_Str__Python__Identifier import Safe_Str__Python__Identifier
+
+def dict_to_obj(target):
+    if isinstance(target, Mapping):
+        new_dict = {}
+        for key, value in target.items():                                        # Sanitize the key to ensure it's a valid Python identifier
+            safe_key = str(Safe_Str__Python__Identifier(str(key)))
+            new_dict[safe_key] = dict_to_obj(value)                              # Recursively convert elements in the dict
+        return __(**new_dict)
+    elif isinstance(target, list):                                               # Recursively convert elements in the list
+        return [dict_to_obj(item) for item in target]
+    elif isinstance(target, tuple):                                              # Recursively convert elements in the tuple
+        return tuple(dict_to_obj(item) for item in target)
+
+    return target
+
+def obj_to_dict(target):                                                            # Recursively converts an object (SimpleNamespace) back into a dictionary."""
+    if isinstance(target, SimpleNamespace):                                         # Convert SimpleNamespace attributes to a dictionary
+        return {key: obj_to_dict(value) for key, value in target.__dict__.items()}
+    elif isinstance(target, list):                                                  # Handle lists: convert each item in the list
+        return [obj_to_dict(item) for item in target]
+    elif isinstance(target, tuple):                                                 # Handle tuples: convert each item and return as a tuple
+        return tuple(obj_to_dict(item) for item in target)
+    elif isinstance(target, set):                                                   # Handle sets: convert each item and return as a set
+        return {obj_to_dict(item) for item in target}
+    return target                                                                   # Return non-object types as is
+
+def str_to_obj(target):
+    if hasattr(target, 'json'):
+        return dict_to_obj(target.json())
+    return dict_to_obj(json.loads(target))
+
+
+json_to_obj         = str_to_obj
+obj                 = dict_to_obj

osbot_utils/type_safe/Type_Safe.py

@@ -93,8 +93,7 @@ def update_from_kwargs(self, **kwargs):                         # Update instanc
         return self
 
     def obj(self):
-        from osbot_utils.utils.Objects import dict_to_obj
-
+        from osbot_utils.testing.__helpers import dict_to_obj
         return dict_to_obj(self.json())
 
     def serialize_to_dict(self):                                        # todo: see if we need this method or if the .json() is enough

osbot_utils/type_safe/Type_Safe__Base.py

@@ -1,7 +1,6 @@
 import types
 from typing                                                       import get_args, Union, Optional, Any, ForwardRef, Literal
 from osbot_utils.utils.Dev                                        import pprint
-from osbot_utils.utils.Objects                                    import obj
 from osbot_utils.type_safe.primitives.domains.identifiers.Obj_Id  import Obj_Id
 from osbot_utils.type_safe.type_safe_core.shared.Type_Safe__Cache import type_safe_cache
 
@@ -144,6 +143,7 @@ def print_obj(self):
         pprint(self.obj())
 
     def obj(self):
+        from osbot_utils.testing.__helpers import obj
         return obj(self.json())
 
 # todo: see if we should/can move this to the Objects.py file

osbot_utils/type_safe/Type_Safe__Primitive.py

@@ -77,7 +77,7 @@ def __to_primitive__(self):                                     # Convert this T
         return str(self)                                            # fallback
 
     def obj(self):                                                                  # Get configuration as namespace object
-        from osbot_utils.utils.Objects import dict_to_obj
+        from osbot_utils.testing.__helpers import dict_to_obj
         return dict_to_obj(self.__cls_kwargs__())
 
     def __cls_kwargs__(self):                                                      # Get class-level kwargs (configuration)

osbot_utils/type_safe/primitives/domains/identifiers/safe_str/Safe_Str__Python__Identifier.py

@@ -0,0 +1,46 @@
+import re
+import keyword
+from osbot_utils.type_safe.primitives.core.Safe_Str import Safe_Str
+
+class Safe_Str__Python__Identifier(Safe_Str):
+    """
+    Ensures strings are valid Python identifiers.
+
+    Rules:
+    - Must start with letter or underscore
+    - Can only contain letters, numbers, underscores
+    - Cannot be a Python keyword
+
+    Transformations:
+    - Converts invalid starting characters (e.g., '8b1a...' → '_8b1a...')
+    - Replaces invalid characters with underscores
+    - Handles Python keywords by prefixing with underscore
+
+    Examples:
+        '8b1a9953c4' → '_8b1a9953c4'
+        'my-var' → 'my_var'
+        'class' → '_class'
+    """
+    max_length       = 255
+    regex            = re.compile(r'[^a-zA-Z0-9_]')
+    replacement_char = '_'
+    to_lower_case    = False
+    trim_whitespace  = True
+
+    def __new__(cls, value: str = None):
+        instance = super().__new__(cls, value)
+        result = str(instance)
+
+        if not result:
+            return str.__new__(cls, '_')
+
+        # Ensure starts with letter or underscore
+        if not (result[0].isalpha() or result[0] == '_'):
+            result = '_' + result
+
+        # Check if it's a Python keyword
+
+        if keyword.iskeyword(result):
+            result = '_' + result
+
+        return str.__new__(cls, result)