fixed edge case with base classes null assigments causing side effects

Author: DinisCruz

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           ,

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