Merge dev into main

Author: DinisCruz

README.md

@@ -1,6 +1,6 @@
 # OSBot-Utils
 
-![Current Release](https://img.shields.io/badge/release-v3.51.0-blue)
+![Current Release](https://img.shields.io/badge/release-v3.51.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/steps/Type_Safe__Step__Class_Kwargs.py

@@ -103,18 +103,21 @@ def process_annotation(self, cls      : Type           ,
                                  var_name : str            ,
                                  var_type : Type           ):
 
-        class_declares_annotation = var_name in getattr(base_cls, '__annotations__', {})
-
-        if not hasattr(base_cls, var_name):
-            self.handle_undefined_var(cls, kwargs, var_name, var_type)
-        elif class_declares_annotation and base_cls is cls:
-            origin = type_safe_cache.get_origin(var_type)                               # Only recalculate default for Type[T] annotations
-            if origin is type:
-                self.handle_undefined_var(cls, kwargs, var_name, var_type)
-            else:
-                self.handle_defined_var(base_cls, var_name, var_type)
-        else:
-            self.handle_defined_var(base_cls, var_name, var_type)
+        class_declares_annotation = var_name in getattr(base_cls, '__annotations__', {})    # Check if this class has the annotation in its own __annotations__
+        class_has_own_value       = var_name in base_cls.__dict__                           # Check if this class defines its own value (not inherited)
+
+        if not hasattr(base_cls, var_name):                                                 # Case 1: No value exists anywhere in hierarchy
+            self.handle_undefined_var(cls, kwargs, var_name, var_type)                      #         Create fresh default value for this type
+        elif class_declares_annotation and base_cls is cls and not class_has_own_value:     # Case 2: Target class redeclares annotation without own value
+            self.handle_undefined_var(cls, kwargs, var_name, var_type)                      #         Create fresh default, don't inherit parent's explicit None
+        elif class_declares_annotation and base_cls is cls:                                 # Case 3: Target class declares annotation with its own value
+            origin = type_safe_cache.get_origin(var_type)                                   #         Check if it's a Type[T] annotation
+            if origin is type:                                                              #         Type[T] annotations need special handling
+                self.handle_undefined_var(cls, kwargs, var_name, var_type)                  #         Recalculate default for Type[T]
+            else:                                                                           #         Normal annotation with explicit value
+                self.handle_defined_var(base_cls, var_name, var_type)                       #         Validate the defined value
+        else:                                                                               # Case 4: Inherited value from parent class
+            self.handle_defined_var(base_cls, var_name, var_type)                           #         Use and validate the inherited value
 
     def process_annotations(self, cls      : Type           ,                           # Process all annotations
                                   base_cls : Type           ,

osbot_utils/type_safe/type_safe_core/steps/Type_Safe__Step__From_Json.py

@@ -308,8 +308,9 @@ def deserialize_nested_dict(self, value_class, dict_value):
             return dict_value  # No type info, use raw dict
 
     def deserialize_type_safe_value(self, value_class, dict_value):                         # Handle deserialization of Type_Safe subclass values.
-        if 'node_type' in dict_value:
-            value_class = type_safe_convert.get_class_from_class_name(dict_value['node_type'])
+        value = dict_value.get('node_type')
+        if value:
+            value_class = type_safe_convert.get_class_from_class_name(value)
 
         return self.deserialize_from_dict(value_class(), dict_value)
 

osbot_utils/version

@@ -1 +1 @@
-v3.51.0
+v3.51.1

pyproject.toml

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

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

@@ -71,7 +71,7 @@ def __init__(self):                     # this will make the __annotations__ to
         assert an_class.an_str == 'new_value'
         assert an_class.an_bool == False
 
-    def test__bug__type_annotation__non_none_parent_default(self):
+    def test__regression__type_annotation__non_none_parent_default(self):
         # What happens when parent has a non-None default?
         # This combines BOTH bugs:
         # 1. Subclass inherits parent's value (Base_Handler) instead of auto-assigning Extended_Handler
@@ -99,3 +99,5 @@ class Extended_Config(Base_Config):
         with pytest.raises(ValueError, match=re.escape(error_message)):
             Extended_Config()                                           # BUG: should auto-assign Extended_Handler
 
+
+

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

@@ -2000,3 +2000,26 @@ class Types_L2(Types_L1):
         with Types_L2() as _:
             #assert _.node_type is None                                  # BUG: should be Node_L2
             assert _.node_type is Node_L2
+
+    def test__regression__base_class_none_prevents_object_creation(self):
+        from osbot_utils.type_safe.primitives.core.Safe_Str import Safe_Str
+        from osbot_utils.testing.__ import __
+
+        class Base_Class(Type_Safe):
+            an_str : Safe_Str = None                        # BUG: this is preventing creation
+
+        class With_Base(Base_Class):
+            an_str : Safe_Str                               # BUG: this should have been created
+
+        class An_Class(Type_Safe):
+            an_str : Safe_Str
+
+        assert An_Class  ().json() == {'an_str': ''}
+        assert An_Class  ().obj () == __(an_str='')
+        assert Base_Class().json() == {'an_str': None}
+        assert Base_Class().obj () == __(an_str=None)
+        # assert With_Base ().json() == {'an_str': None}      # BUG
+        # assert With_Base ().obj () == __(an_str=None)       # BUG
+
+        assert With_Base ().json() == {'an_str': ''}      # FIXED
+        assert With_Base ().obj () == __(an_str='')       # FIXED

tests/unit/type_safe/type_safe_core/steps/test_Type_Safe__Step__From_Json.py

@@ -5,6 +5,7 @@
 from enum                                                                            import Enum
 from typing                                                                          import Dict, List, Set, Any, Optional, ForwardRef
 from unittest                                                                        import TestCase
+from osbot_utils.utils.Env                                                           import in_github_action
 from osbot_utils.type_safe.Type_Safe                                                 import Type_Safe
 from osbot_utils.type_safe.primitives.domains.cryptography.safe_str.Safe_Str__Hash   import Safe_Str__Hash
 from osbot_utils.type_safe.primitives.domains.files.safe_str.Safe_Str__File__Path    import Safe_Str__File__Path
@@ -521,7 +522,10 @@ class Large_Class(Type_Safe):
         elapsed = time.time() - start
 
         assert len(obj.items) == 1000
-        assert elapsed < 0.01                                    # Should complete in under 10ms
+        if in_github_action():
+            assert elapsed < 0.05                                    # in GH Actions this is about ~10ms
+        else:
+            assert elapsed < 0.01                                    # on dev laptop this is ~2ms
 
     def test__forward_ref_in_list_works(self):                              # Forward refs in List work correctly """