Merge dev into main

Author: DinisCruz

README.md

@@ -1,6 +1,6 @@
 # OSBot-Utils
 
-![Current Release](https://img.shields.io/badge/release-v3.50.0-blue)
+![Current Release](https://img.shields.io/badge/release-v3.50.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/helpers/cache_on_self/Cache_Storage.py

@@ -1,5 +1,5 @@
 from weakref import WeakKeyDictionary
-from typing import Any, Dict, List
+from typing  import Any, List
 
 class Cache_Storage:    # Handles all cache storage without polluting instance attributes
 

osbot_utils/type_safe/type_safe_core/shared/Type_Safe__Validation.py

@@ -208,7 +208,14 @@ def check_if__type_matches__obj_annotation__for_attr(self, target, attr_name, va
                     if type_arg == value:
                         return True
                     if isinstance(type_arg, (str, ForwardRef)):                             # Handle forward reference
-                        type_arg = target.__class__                                         # If it's a forward reference, the target class should be the containing class
+                        forward_name = type_arg.__forward_arg__ if isinstance(type_arg, ForwardRef) else type_arg
+                        resolved_type = None                                                # Walk MRO to find the actual class
+                        for base_cls in target.__class__.__mro__:
+                            if base_cls.__name__ == forward_name:
+                                resolved_type = base_cls
+                                break
+                        type_arg = resolved_type if resolved_type else target.__class__     # Fallback to instance class if not found
+
                     return isinstance(value, type) and issubclass(value, type_arg)          # Check that value is a type and is subclass of type_arg
                 else:
                     return isinstance(value, type)

osbot_utils/type_safe/type_safe_core/steps/Type_Safe__Step__Class_Kwargs.py

@@ -1,8 +1,5 @@
 from typing                                                                     import Dict, Any, Type
-
-from osbot_utils.type_safe.Type_Safe__Primitive import Type_Safe__Primitive
-from osbot_utils.type_safe.primitives.domains.identifiers.Obj_Id                import Obj_Id
-from osbot_utils.type_safe.primitives.domains.identifiers.Random_Guid           import Random_Guid
+from osbot_utils.type_safe.Type_Safe__Primitive                                 import Type_Safe__Primitive
 from osbot_utils.type_safe.type_safe_core.shared.Type_Safe__Cache               import type_safe_cache, Type_Safe__Cache
 from osbot_utils.type_safe.type_safe_core.shared.Type_Safe__Shared__Variables   import IMMUTABLE_TYPES
 from osbot_utils.type_safe.type_safe_core.shared.Type_Safe__Validation          import type_safe_validation
@@ -100,15 +97,23 @@ def handle_defined_var(self, base_cls : Type ,
         type_safe_validation.validate_variable_type(base_cls, var_name, var_type, var_value)
         type_safe_validation.validate_type_immutability(var_name, var_type)
 
-    def process_annotation(self, cls      : Type           ,                            # Process single annotation
+    def process_annotation(self, cls      : Type           ,
                                  base_cls : Type           ,
                                  kwargs   : Dict[str, Any] ,
                                  var_name : str            ,
-                                 var_type : Type           )\
-                       -> None:
-        if not hasattr(base_cls, var_name):                                             # Handle undefined variables
+                                 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)
-        else:                                                                           # Handle defined variables
+        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)
 
     def process_annotations(self, cls      : Type           ,                           # Process all annotations
@@ -119,6 +124,7 @@ def process_annotations(self, cls      : Type           ,
             for var_name, var_type in type_safe_cache.get_class_annotations(base_cls):
                 self.process_annotation(cls, base_cls, kwargs, var_name, var_type)
 
+
     def process_mro_class(self, base_cls : Type           ,                             # Process class in MRO chain
                                 kwargs   : Dict[str, Any] )\
                        -> None:

osbot_utils/version

@@ -1 +1 @@
-v3.50.0
+v3.50.1

pyproject.toml

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

tests/unit/type_safe/primitives/domains/identifiers/test_Obj_Id.py

@@ -1,5 +1,6 @@
-from unittest                                                       import TestCase
+import re
 import pytest
+from unittest                                                       import TestCase
 from osbot_utils.helpers.duration.decorators.capture_duration       import capture_duration
 from osbot_utils.testing.__                                         import __
 from osbot_utils.testing.performance.Performance_Measure__Session   import Performance_Measure__Session
@@ -119,7 +120,8 @@ def test__new_obj_id__format(self):
 
         assert len(obj_id)       == 8
         assert is_obj_id(obj_id) is True
-        assert obj_id.islower()  is True                                                    # Always lowercase
+        assert re.fullmatch(r"[a-z0-9]{8}", obj_id)                                         # Always lowercase
+        #assert obj_id.islower()  is True                                                   # we can't use this , since when obj_id is all numbers, islower returns false
 
     def test__new_obj_id__uniqueness(self):                                                 # Test new_obj_id generates unique values
         ids = [new_obj_id() for _ in range(1000)]

tests/unit/type_safe/test_Type_Safe.py

@@ -1085,17 +1085,6 @@ def label(self, value):
             test_class.data = 123                                                                   # confirm that type safety is still working on the main class
 
     def test_validate_type_immutability(self):                                        # Tests type immutability validation
-        # class Simple_Type(Type_Safe):
-        #     valid_int   : int        = 42                                            # valid immutable type
-        #     valid_str   : str        = 'abc'                                         # valid immutable type
-        #     valid_bool  : bool       = True                                          # valid immutable type
-        #     valid_tuple : tuple      = (1,2)                                         # valid immutable type
-        #
-        # simple = Simple_Type()                                                       # Should work fine with valid types
-        # assert simple.valid_int   == 42
-        # assert simple.valid_str   == 'abc'
-        # assert simple.valid_bool  == True
-        # assert simple.valid_tuple == (1,2)
 
         with pytest.raises(ValueError, match= "variable 'invalid_list' is defined as type '<class 'list'>' which is not supported by Type_Safe" ):                                    # Test invalid mutable type
             class Invalid_Type(Type_Safe):

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

@@ -1,4 +1,6 @@
+import re
 import pytest
+from typing                                                           import Type
 from unittest                                                         import TestCase
 from osbot_utils.type_safe.Type_Safe                                  import Type_Safe
 
@@ -69,3 +71,31 @@ 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):
+        # 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
+        # 2. Then validation fails because Base_Handler is not a subclass of Extended_Handler
+
+        class Base_Handler(Type_Safe):
+            pass
+
+        class Extended_Handler(Base_Handler):
+            pass
+
+        class Base_Config(Type_Safe):
+            handler_type: Type[Base_Handler] = Base_Handler             # Non-None default
+
+        class Extended_Config(Base_Config):
+            handler_type: Type[Extended_Handler]                        # Re-declare with more specific type
+
+        # Parent default is Base_Handler
+        with Base_Config() as _:
+            assert _.handler_type is Base_Handler                       # Correct
+
+        # BUG: Subclass inherits parent's value (Base_Handler), then validation fails
+        #      because Base_Handler is not a subclass of Extended_Handler
+        error_message = "On Extended_Config, invalid type for attribute 'handler_type'. Expected 'typing.Type["
+        with pytest.raises(ValueError, match=re.escape(error_message)):
+            Extended_Config()                                           # BUG: should auto-assign Extended_Handler
+