fixed couple issues with Type_Safe__Fast_Create__Cache

added final Hypothsis_H which captures a number of powerful benchmarks (including a comparison with the original Python, dataclass and Pydantic data sets)

Author: DinisCruz

osbot_utils/type_safe/type_safe_core/fast_create/Type_Safe__Fast_Create__Cache.py

@@ -10,7 +10,7 @@
 #
 # ═══════════════════════════════════════════════════════════════════════════════
 
-from typing                                                                                         import Any, Dict, Set, Type
+from typing                                                                                         import Any, Dict, Set, Type, get_type_hints, get_origin
 from osbot_utils.type_safe.Type_Safe__Primitive                                                     import Type_Safe__Primitive
 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
@@ -31,12 +31,14 @@
 
 class Type_Safe__Fast_Create__Cache:                                              # Schema generation and caching
 
-    schema_cache : Dict[Type, Schema__Type_Safe__Fast_Create__Class]              # Class -> Schema mapping
-    generating   : Set[Type]                                                      # Guards against recursion
+    schema_cache     : Dict[Type, Schema__Type_Safe__Fast_Create__Class]          # Class -> Schema mapping
+    type_hints_cache : Dict[Type, Dict[str, Type]]                                # Class -> type hints mapping
+    generating       : Set[Type]                                                  # Guards against recursion
 
     def __init__(self):
-        self.schema_cache = {}                                                    # Regular dict - classes persist
-        self.generating   = set()                                                 # Recursion guard
+        self.schema_cache     = {}                                                # Regular dict - classes persist
+        self.type_hints_cache = {}                                                # Cache for get_type_hints results
+        self.generating       = set()                                             # Recursion guard
 
     def __enter__(self):
         return self
@@ -61,6 +63,7 @@ def warm_cache(self, cls: Type) -> None:                                      #
 
     def clear_cache(self) -> None:                                                # Clear all cached schemas (for testing)
         self.schema_cache.clear()
+        self.type_hints_cache.clear()
         self.generating.clear()
 
     def is_generating(self, cls: Type) -> bool:                                   # Check if schema generation in progress
@@ -76,6 +79,7 @@ def generate_schema(self, cls: Type) -> Schema__Type_Safe__Fast_Create__Class:
         try:
             template      = cls()                                                 # Create template to get defaults
             template_dict = template.__dict__.copy()
+            type_hints    = self.get_type_hints_safe(cls)                         # Get type annotations
 
             fields         = []
             static_dict    = {}
@@ -86,7 +90,8 @@ def generate_schema(self, cls: Type) -> Schema__Type_Safe__Fast_Create__Class:
                 if name.startswith('_'):                                          # Skip private attributes
                     continue
 
-                field = self.classify_field(name, value)
+                type_hint = type_hints.get(name)                                  # Get annotation for this field
+                field     = self.classify_field(name, value, type_hint)
                 fields.append(field)
 
                 if field.mode == FIELD_MODE__STATIC:
@@ -104,8 +109,14 @@ def generate_schema(self, cls: Type) -> Schema__Type_Safe__Fast_Create__Class:
         finally:
             self.generating.discard(cls)                                          # Remove from generating set
 
-    def classify_field(self, name: str, value: Any) -> Schema__Type_Safe__Fast_Create__Field:             # Classify field by its value type
+    def classify_field(self, name: str, value: Any, type_hint: Type = None) -> Schema__Type_Safe__Fast_Create__Field:             # Classify field by its value type
         if self.is_immutable(value):
+            # Check if None value has a Type_Safe type hint (On_Demand pattern)
+            if value is None and type_hint is not None:
+                if self.is_type_safe_type_hint(type_hint):                        # Type hint is a Type_Safe class
+                    return Schema__Type_Safe__Fast_Create__Field(name         = name      ,
+                                                                 mode         = FIELD_MODE__NESTED,
+                                                                 nested_class = type_hint )
             return Schema__Type_Safe__Fast_Create__Field(name         = name               ,
                                                          mode         = FIELD_MODE__STATIC ,
                                                          static_value = value              )
@@ -141,6 +152,32 @@ def is_nested_type_safe(self, value: Any) -> bool:                            #
             return False
         return True
 
+    def is_type_safe_type_hint(self, type_hint: Type) -> bool:                    # Check if type hint is a Type_Safe class
+        from osbot_utils.type_safe.Type_Safe import Type_Safe                     # Circular dependency
+        if type_hint is None:
+            return False
+        if get_origin(type_hint) is not None:                                     # Skip generic types like Optional[X]
+            return False
+        if not isinstance(type_hint, type):                                       # Must be a class
+            return False
+        if not issubclass(type_hint, Type_Safe):                                  # Must be Type_Safe subclass
+            return False
+        if issubclass(type_hint, Type_Safe__Primitive):                           # Skip primitives
+            return False
+        if issubclass(type_hint, (Type_Safe__List, Type_Safe__Dict, Type_Safe__Set)):  # Skip collections
+            return False
+        return True
+
+    def get_type_hints_safe(self, cls: Type) -> Dict[str, Type]:                  # Get type hints with caching
+        if cls in self.type_hints_cache:
+            return self.type_hints_cache[cls]
+        try:
+            hints = get_type_hints(cls)
+        except Exception:                                                         # Some classes fail get_type_hints
+            hints = {}
+        self.type_hints_cache[cls] = hints
+        return hints
+
     # ═══════════════════════════════════════════════════════════════════════════
     # Factory Function Generation
     # ═══════════════════════════════════════════════════════════════════════════
@@ -168,6 +205,12 @@ def get_factory_func(self, value: Any):                                       #
         if isinstance(value, set):
             return set
 
+        # Handle when value is a class/type itself
+        if isinstance(value, type):                                               # Value IS a class
+            captured_type = value                                                 # Capture for lambda
+            return lambda: captured_type                                          # Return class itself (not instance)
+
+
         value_type = type(value)                                                  # Default: use type constructor
         return lambda: value_type()
 

tests/unit/type_safe/type_safe_core/config/_performance/hypothesis/hypothesis_H__production_benchmarks/hypothesis_H__brief.md

@@ -0,0 +1,84 @@
+# Hypothesis H: Production Performance Benchmarks
+
+**Status**: ✅ Complete  
+**Depends On**: Hypothesis G (wiring in Type_Safe)
+
+---
+
+## Hypothesis
+
+> Using `Type_Safe__Config` context manager with `fast_create=True` and/or `skip_validation=True` provides significant performance improvements over default Type_Safe behavior.
+
+---
+
+## Three Comparisons
+
+| Test File | Baseline | Target | Expected Improvement |
+|-----------|----------|--------|---------------------|
+| `test_perf__Hypothesis_H__fast_create.py` | Default Type_Safe | `fast_create=True` | 50-85% |
+| `test_perf__Hypothesis_H__skip_validation.py` | Default `__setattr__` | `skip_validation=True` | 50-80% |
+| `test_perf__Hypothesis_H__fast_create_skip_validation.py` | Default Type_Safe | Both flags | 60-90% |
+
+---
+
+## Benchmark Categories
+
+### Object Creation (A series)
+- A_01: Empty class
+- A_02: Primitives only (str, int, bool, float)
+- A_03: With collections (List, Dict)
+- A_04: Many fields (10 fields)
+- A_05: One nested Type_Safe
+- A_06: Three nested Type_Safe
+- A_07: Deep nested (3 levels)
+- A_08: MGraph-like (complex structure)
+
+### Batch Creation (B series)
+- B_01-B_04: x10 objects of various complexity
+
+### Attribute Assignment (C series) - skip_validation only
+- C_01-C_04: x100 objects, x400 assignments
+
+### Create + Modify (D series) - combined test only
+- D_01-D_04: Real-world patterns (create then modify)
+
+---
+
+## Usage
+
+```python
+# Run individual benchmark
+pytest test_perf__Hypothesis_H__fast_create.py -v
+
+# All benchmarks
+pytest test_perf__Hypothesis_H*.py -v
+```
+
+---
+
+## Key Findings
+
+| Scenario | Improvement | Notes |
+|----------|-------------|-------|
+| Simple classes | 30-50% | Less validation to skip |
+| Nested classes | 50-70% | Recursive creation overhead eliminated |
+| Complex (MGraph-like) | 70-85% | Maximum benefit |
+| Batch x10 | Scales linearly | 10x objects = 10x savings |
+| setattr bypass | 60-80% | Direct `object.__setattr__` |
+
+---
+
+## Prerequisites
+
+1. ✅ Hypothesis G complete (fast_create infrastructure)
+2. ✅ Type_Safe.__init__ wired to check config
+3. ✅ Type_Safe.__setattr__ wired to check config
+4. ✅ All 117 integration tests passing
+
+---
+
+## Related Files
+
+- **Detailed Debrief**: `Hypothesis_H__debrief_on_Type_Safe_changes.md`
+- **Integration Tests**: `test_Type_Safe__Fast_Create__*.py` (5 files, 117 tests)
+- **Performance Tests**: `test_perf__Hypothesis_H__*.py` (3 files)