added support to Fast_API_Routes for Type_Safe__Primitive which is a major use case for post methods (major feature :) )

Author: DinisCruz

osbot_fast_api/api/Fast_API_Routes.py

@@ -6,6 +6,7 @@
 from osbot_utils.decorators.lists.index_by                   import index_by
 from osbot_utils.type_safe.Type_Safe__Primitive              import Type_Safe__Primitive
 from fastapi.exceptions                                      import RequestValidationError
+from osbot_utils.type_safe.shared.Type_Safe__Cache           import type_safe_cache
 from osbot_fast_api.utils.type_safe.Type_Safe__To__BaseModel import type_safe__to__basemodel
 
 
@@ -31,15 +32,23 @@ def add_route_with_body(self, function, methods):
         sig        = inspect.signature(function)
         type_hints = get_type_hints(function)
 
-        # Find Type_Safe parameters and convert them to BaseModel classes
         type_safe_conversions = {}
+        primitive_field_types = {}                                                                  # Track which fields are Type_Safe__Primitive
 
         for param_name, param in sig.parameters.items():
             if param_name == 'self':
                 continue
             param_type = type_hints.get(param_name)
             if param_type and inspect.isclass(param_type):
                 if issubclass(param_type, Type_Safe) and not issubclass(param_type, Type_Safe__Primitive):
+
+                    annotations = type_safe_cache.get_class_annotations(param_type)                 # For Type_Safe classes, also track their primitive fields
+                    for field_name, field_type in annotations:
+                        if isinstance(field_type, type) and issubclass(field_type, Type_Safe__Primitive):
+                            if param_name not in primitive_field_types:
+                                primitive_field_types[param_name] = {}
+                            primitive_field_types[param_name][field_name] = field_type
+
                     basemodel_class = type_safe__to__basemodel.convert_class(param_type)
                     type_safe_conversions[param_name] = (param_type, basemodel_class)
 
@@ -51,17 +60,27 @@ def wrapper(**kwargs):
                     if param_name in type_safe_conversions:
                         type_safe_class, _ = type_safe_conversions[param_name]
                         if isinstance(param_value, dict):
+                            # Convert primitive fields back to Type_Safe__Primitive instances
+                            if param_name in primitive_field_types:
+                                for field_name, primitive_class in primitive_field_types[param_name].items():
+                                    if field_name in param_value:
+                                        param_value[field_name] = primitive_class(param_value[field_name])
                             converted_kwargs[param_name] = type_safe_class(**param_value)
                         else:
-                            data = param_value.model_dump()                         # Get the data from BaseModel
-                            converted_kwargs[param_name] = type_safe_class(**data)  # Create instance of original Type_Safe class
+                            data = param_value.model_dump()
+                            # Convert primitive fields here too
+                            if param_name in primitive_field_types:
+                                for field_name, primitive_class in primitive_field_types[param_name].items():
+                                    if field_name in data:
+                                        data[field_name] = primitive_class(data[field_name])
+                            converted_kwargs[param_name] = type_safe_class(**data)
                     else:
                         converted_kwargs[param_name] = param_value
 
                 try:
                     result = function(**converted_kwargs)
                 except Exception as e:
-                    raise HTTPException(status_code=400, detail=f"{type(e).__name__}: {e}") # Convert business logic validation errors to HTTP 400
+                    raise HTTPException(status_code=400, detail=f"{type(e).__name__}: {e}")
 
                 if isinstance(result, Type_Safe):
                     return type_safe__to__basemodel.convert_instance(result).model_dump()

osbot_fast_api/utils/type_safe/BaseModel__To__Type_Safe.py

@@ -1,10 +1,11 @@
-from typing                                                    import Type, Dict, Any, Optional, get_args, Union, List
-from osbot_utils.type_safe.decorators.type_safe                import type_safe
-from osbot_utils.type_safe.shared.Type_Safe__Shared__Variables import IMMUTABLE_TYPES
-from pydantic                                                  import BaseModel
-from pydantic_core                                             import PydanticUndefined
-from osbot_utils.type_safe.Type_Safe                           import Type_Safe
-from osbot_utils.type_safe.shared.Type_Safe__Cache             import type_safe_cache
+from typing                                                     import Type, Dict, Any, Optional, get_args, Union, List
+from osbot_utils.type_safe.Type_Safe__Primitive                 import Type_Safe__Primitive
+from osbot_utils.type_safe.decorators.type_safe                 import type_safe
+from osbot_utils.type_safe.shared.Type_Safe__Shared__Variables  import IMMUTABLE_TYPES
+from pydantic                                                   import BaseModel
+from pydantic_core                                              import PydanticUndefined
+from osbot_utils.type_safe.Type_Safe                            import Type_Safe
+from osbot_utils.type_safe.shared.Type_Safe__Cache              import type_safe_cache
 
 
 class BaseModel__To__Type_Safe(Type_Safe):
@@ -220,6 +221,9 @@ def convert_nested_value(self, value     : Any ,
         if value is None:
             return None
 
+        if isinstance(expected_type, type) and issubclass(expected_type, Type_Safe__Primitive):
+            return expected_type(value)                                                  # Create Type_Safe__Primitive instance
+
         if isinstance(expected_type, type) and issubclass(expected_type, BaseModel):     # Nested BaseModel
             if isinstance(value, dict):                                                  # Dict representation
                 nested_model = expected_type(**value)                                    # Create BaseModel instance

osbot_fast_api/utils/type_safe/Type_Safe__To__BaseModel.py

@@ -1,4 +1,5 @@
 from typing                                         import Type, Dict, Any, Optional, get_args, Union, List
+from osbot_utils.type_safe.Type_Safe__Primitive     import Type_Safe__Primitive
 from osbot_utils.type_safe.decorators.type_safe     import type_safe
 from pydantic                                       import BaseModel, Field, create_model
 from osbot_utils.type_safe.Type_Safe                import Type_Safe
@@ -77,6 +78,11 @@ def convert_type(self, type_safe_type: Any                              # Type a
                 return Optional[converted_args[0]]
             return Union[converted_args]
 
+        if isinstance(type_safe_type, type) and issubclass(type_safe_type, Type_Safe__Primitive):       # Type_Safe__Primitive should map to its base primitive type for Pydantic
+            if type_safe_type.__primitive_base__:                                                       # if __primitive_base__ is set
+                return type_safe_type.__primitive_base__                                                # return it
+
+
         if isinstance(type_safe_type, type) and issubclass(type_safe_type, Type_Safe):  # Handle Type_Safe classes
             return self.convert_class(type_safe_type)                                   # Recursively convert
 
@@ -105,7 +111,9 @@ def extract_instance_data(self, type_safe_instance: Type_Safe
         instance_locals = type_safe_instance.__locals__()                               # Get all fields from instance
 
         for field_name, field_value in instance_locals.items():
-            if isinstance(field_value, Type_Safe__List):                                # Convert Type_Safe collections
+            if isinstance(field_value, Type_Safe__Primitive):                           # Convert Type_Safe__Primitive to its base type value
+                data[field_name] = field_value.__primitive_base__(field_value)
+            elif isinstance(field_value, Type_Safe__List):                                # Convert Type_Safe collections
                 data[field_name] = self.convert_list(field_value)
             elif isinstance(field_value, Type_Safe__Dict):
                 data[field_name] = self.convert_dict(field_value)