turboapi 0.4.12__cp313-cp313-win_amd64.whl → 0.4.13__cp313-cp313-win_amd64.whl

turboapi/request_handler.py

@@ -18,6 +18,11 @@ class RequestBodyParser:
         """
         Parse JSON body and extract parameters for handler.
         
+        Supports multiple patterns:
+        1. Single parameter (dict/list/Model) - receives entire body
+        2. Multiple parameters - extracts fields from JSON
+        3. Satya Model - validates entire body
+        
         Args:
             body: Raw request body bytes
             handler_signature: Signature of the handler function
@@ -34,9 +39,42 @@ class RequestBodyParser:
             raise ValueError(f"Invalid JSON body: {e}")
         
         parsed_params = {}
+        params_list = list(handler_signature.parameters.items())
+        
+        # PATTERN 1: Single parameter that should receive entire body
+        # Examples: handler(data: dict), handler(items: list), handler(request: Model)
+        if len(params_list) == 1:
+            param_name, param = params_list[0]
+            
+            # Check if parameter is a Satya Model
+            try:
+                is_satya_model = inspect.isclass(param.annotation) and issubclass(param.annotation, Model)
+            except Exception:
+                is_satya_model = False
+            
+            if is_satya_model:
+                # Validate entire JSON body against Satya model
+                try:
+                    validated_model = param.annotation.model_validate(json_data)
+                    parsed_params[param_name] = validated_model
+                    return parsed_params
+                except Exception as e:
+                    raise ValueError(f"Validation error for {param_name}: {e}")
+            
+            # If annotated as dict or list, pass entire body
+            elif param.annotation in (dict, list) or param.annotation == inspect.Parameter.empty:
+                parsed_params[param_name] = json_data
+                return parsed_params
+            
+            # Check for typing.Dict, typing.List, etc.
+            origin = get_origin(param.annotation)
+            if origin in (dict, list):
+                parsed_params[param_name] = json_data
+                return parsed_params
         
-        # Check each parameter in the handler signature
-        for param_name, param in handler_signature.parameters.items():
+        # PATTERN 2: Multiple parameters - extract individual fields
+        # Example: handler(name: str, age: int, email: str)
+        for param_name, param in params_list:
             if param.annotation == inspect.Parameter.empty:
                 # No type annotation, try to match by name
                 if param_name in json_data:
@@ -138,9 +176,21 @@ class ResponseHandler:
         if isinstance(content, Model):
             content = content.model_dump()
         
-        # Ensure content is JSON-serializable
-        if not isinstance(content, (dict, list, str, int, float, bool, type(None))):
-            content = str(content)
+        # Recursively convert any nested Satya models in dicts/lists
+        def make_serializable(obj):
+            if isinstance(obj, Model):
+                return obj.model_dump()
+            elif isinstance(obj, dict):
+                return {k: make_serializable(v) for k, v in obj.items()}
+            elif isinstance(obj, (list, tuple)):
+                return [make_serializable(item) for item in obj]
+            elif isinstance(obj, (str, int, float, bool, type(None))):
+                return obj
+            else:
+                # Try to convert to string for unknown types
+                return str(obj)
+        
+        content = make_serializable(content)
         
         return {
             "content": content,

turboapi/rust_integration.py

@@ -128,91 +128,14 @@ class RustIntegratedTurboAPI(TurboAPI):
                 # Create enhanced handler with automatic body parsing
                 enhanced_handler = create_enhanced_handler(route.handler, route)
                 
-                # Create Rust-compatible handler wrapper
-                def create_rust_handler(python_handler, route_def):
-                    def rust_handler(rust_request):
-                        """Rust-callable handler that calls Python function with automatic body parsing."""
-                        try:
-                            # Extract request data from Rust
-                            path = rust_request.path
-                            query_string = rust_request.query_string
-                            
-                            # Get headers - try method call first, then attribute
-                            try:
-                                headers = rust_request.get_headers() if callable(getattr(rust_request, 'get_headers', None)) else {}
-                            except:
-                                headers = getattr(rust_request, 'headers', {})
-                            
-                            # Get body - Rust sets it as 'body' attribute (bytes)
-                            body = getattr(rust_request, 'body', b'')
-                            
-                            # Also try get_body if it's set
-                            if not body:
-                                get_body_attr = getattr(rust_request, 'get_body', None)
-                                if get_body_attr is not None:
-                                    if callable(get_body_attr):
-                                        body = get_body_attr()
-                                    else:
-                                        body = get_body_attr
-
-                            # Parse query parameters
-                            query_params = {}
-                            if query_string:
-                                # Simple query string parsing
-                                for param in query_string.split('&'):
-                                    if '=' in param:
-                                        key, value = param.split('=', 1)
-                                        query_params[key] = value
-
-                            # Parse path parameters
-                            path_params = self._extract_path_params(route_def.path, path)
-
-                            # Prepare arguments for enhanced handler
-                            call_args = {}
-                            
-                            # Add path parameters
-                            call_args.update(path_params)
-                            
-                            # Add query parameters
-                            call_args.update(query_params)
-                            
-                            # Always add body and headers for enhanced handler
-                            call_args['body'] = body if body else b''
-                            call_args['headers'] = headers
-
-                            # Call enhanced handler (handles parsing, validation, response normalization)
-                            result = python_handler(**call_args)
-                            
-                            # Enhanced handler returns normalized format
-                            # {"content": ..., "status_code": ..., "content_type": ...}
-                            # But Rust expects a plain dict that it will JSON serialize
-                            # So just return the content directly
-                            if isinstance(result, dict) and 'content' in result and 'status_code' in result:
-                                # Return just the content - Rust will handle status codes later
-                                # For now, just return the content as a dict
-                                return result['content']
-                            
-                            # Fallback for plain dict responses
-                            return result
-
-                        except Exception as e:
-                            # Return 500 error as plain dict (Rust will serialize it)
-                            import traceback
-                            return {
-                                "error": "Internal Server Error",
-                                "detail": str(e),
-                                "traceback": traceback.format_exc()
-                            }
-
-                    return rust_handler  # noqa: B023
-
-                # Register the ORIGINAL handler directly with Rust
-                # Rust will call it with call0() (no arguments)
-                # The original handler doesn't expect any arguments
+                # For now, just register the original handler
+                # TODO: Implement request data passing from Rust to enable enhanced handler
+                # The Rust server currently calls handlers with call0() (no arguments)
+                # We need to modify the Rust server to pass request data
                 self.rust_server.add_route(
                     route.method.value,
                     route.path,
-                    route.handler  # Pass original handler, not wrapper!
+                    enhanced_handler  # Register enhanced handler directly
                 )
 
                 print(f"{CHECK_MARK} Registered {route.method.value} {route.path} with Rust server")

{turboapi-0.4.12.dist-info → turboapi-0.4.13.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: turboapi
-Version: 0.4.12
+Version: 0.4.13
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License

{turboapi-0.4.12.dist-info → turboapi-0.4.13.dist-info}/RECORD

@@ -1,5 +1,5 @@
-turboapi-0.4.12.dist-info/METADATA,sha256=IBt2GTnjmkVpSOn-PzMpMzXtwdB4jcqesqC2Bvj64_E,1482
-turboapi-0.4.12.dist-info/WHEEL,sha256=TJQY77QRLvXq32tEs9ATmwKO6NAOtuKOAw50eyiSmWU,96
+turboapi-0.4.13.dist-info/METADATA,sha256=Cx_c3TzPTzH999Vc5NxdbruBeIuVIISBgN1xXWMVNdM,1482
+turboapi-0.4.13.dist-info/WHEEL,sha256=TJQY77QRLvXq32tEs9ATmwKO6NAOtuKOAw50eyiSmWU,96
 turboapi/__init__.py,sha256=r9Fphtu9ruHFUhSpBMAGxY5en2wvcnsE1nMp2DDRM6w,692
 turboapi/async_limiter.py,sha256=x2qkloPbg2YelDNUXKya2BwBTq5zVxDHxuaQspIgYBg,2416
 turboapi/async_pool.py,sha256=UVm0A-0jIN4V43jY8a5XEU_L0SSyWGMV2bs5FiQGr2M,4489
@@ -7,11 +7,11 @@ turboapi/decorators.py,sha256=jjJrIXZ3y_yJ231ar24hS09OCDtTqmYA7arpIOcr2kk,1788
 turboapi/main_app.py,sha256=_rH5xUahFvyqk8Y9O4rs7v5m1q4_AbkBHitg04KL6O4,11678
 turboapi/middleware.py,sha256=iqtklH5_GMICuAmmxMBfaFSNZkR8wHSNbwhNscGe-pA,11200
 turboapi/models.py,sha256=VCU68f9MGtDdFb4crsx2e0SHghICg8zjU8OumfdpZLQ,5363
-turboapi/request_handler.py,sha256=KrN9d3r7bO8LUU68X6cXTtl3a2dCoRqmdWrjDW2V2qQ,8413
+turboapi/request_handler.py,sha256=xS9b6HqAGUDRp8D4O09i6jhxmw56771DfvjhRHaMDwU,10752
 turboapi/routing.py,sha256=iCbty56a2J9qnCtxIHQtYf66ZoKVxgISxwCxYvGmgEs,7746
-turboapi/rust_integration.py,sha256=AsdB14odDYHFcMNlKeef0Dh8uqE0lfEqcC4MjSld0tM,14930
+turboapi/rust_integration.py,sha256=d1xqC8cX8kehDlRuDQhVbMPw-cQysmI2ZR-j29JD8GA,10676
 turboapi/security.py,sha256=-XgwBhiqQZdfU7oKLHi-3xN_UwlKiQxpfSQ6kTA0ko8,17230
 turboapi/server_integration.py,sha256=drUhhTasWgQfyhFiAaHKd987N3mnE0qkMab1ylmqd4c,18340
-turboapi/turbonet.cp313-win_amd64.pyd,sha256=M6HuhjYQyUeuzyvYqViyuoyRzmQBIJ6JDls8uZAejms,3659264
+turboapi/turbonet.cp313-win_amd64.pyd,sha256=cIBGcGkdVilk6CEYDc_zD5QatdYSiAWOYyNrG9oBFcw,3664384
 turboapi/version_check.py,sha256=z3O1vIJsWmG_DO271ayYWSwaDfgpFnfJzYRYyowKYMc,9625
-turboapi-0.4.12.dist-info/RECORD,,
+turboapi-0.4.13.dist-info/RECORD,,