turboapi 0.4.12__cp314-cp314-win_amd64.whl → 0.4.15__cp314-cp314-win_amd64.whl

turboapi/request_handler.py

@@ -1,15 +1,107 @@
 """
 Enhanced Request Handler with Satya Integration
 Provides FastAPI-compatible automatic JSON body parsing and validation
+Supports query parameters, path parameters, headers, and request body
 """
 
 import inspect
 import json
+import urllib.parse
 from typing import Any, get_args, get_origin
 
 from satya import Model
 
 
+class QueryParamParser:
+    """Parse query parameters from query string."""
+    
+    @staticmethod
+    def parse_query_params(query_string: str) -> dict[str, Any]:
+        """
+        Parse query string into dict of parameters.
+        Supports multiple values for same key (returns list).
+        
+        Args:
+            query_string: URL query string (e.g., "q=test&limit=10")
+            
+        Returns:
+            Dictionary of parsed query parameters
+        """
+        if not query_string:
+            return {}
+        
+        params = {}
+        parsed = urllib.parse.parse_qs(query_string, keep_blank_values=True)
+        
+        for key, values in parsed.items():
+            # If only one value, return as string; otherwise return as list
+            if len(values) == 1:
+                params[key] = values[0]
+            else:
+                params[key] = values
+        
+        return params
+
+
+class PathParamParser:
+    """Parse path parameters from URL path."""
+    
+    @staticmethod
+    def extract_path_params(route_pattern: str, actual_path: str) -> dict[str, str]:
+        """
+        Extract path parameters from actual path using route pattern.
+        
+        Args:
+            route_pattern: Route pattern with {param} placeholders (e.g., "/users/{user_id}")
+            actual_path: Actual request path (e.g., "/users/123")
+            
+        Returns:
+            Dictionary of extracted path parameters
+        """
+        import re
+        
+        # Convert route pattern to regex
+        # Replace {param} with named capture groups
+        pattern = re.sub(r'\{(\w+)\}', r'(?P<\1>[^/]+)', route_pattern)
+        pattern = f'^{pattern}$'
+        
+        match = re.match(pattern, actual_path)
+        if match:
+            return match.groupdict()
+        
+        return {}
+
+
+class HeaderParser:
+    """Parse and extract headers from request."""
+    
+    @staticmethod
+    def parse_headers(headers_dict: dict[str, str], handler_signature: inspect.Signature) -> dict[str, Any]:
+        """
+        Parse headers and extract parameters needed by handler.
+        
+        Args:
+            headers_dict: Dictionary of request headers
+            handler_signature: Signature of the handler function
+            
+        Returns:
+            Dictionary of parsed header parameters
+        """
+        parsed_headers = {}
+        
+        # Check each parameter in handler signature
+        for param_name, param in handler_signature.parameters.items():
+            # Check if parameter name matches a header (case-insensitive)
+            header_key = param_name.replace('_', '-').lower()
+            
+            for header_name, header_value in headers_dict.items():
+                if header_name.lower() == header_key:
+                    parsed_headers[param_name] = header_value
+                    break
+        
+        return parsed_headers
+
+
 class RequestBodyParser:
     """Parse and validate request bodies using Satya models."""
     
@@ -18,6 +110,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 +131,42 @@ class RequestBodyParser:
             raise ValueError(f"Invalid JSON body: {e}")
         
         parsed_params = {}
+        params_list = list(handler_signature.parameters.items())
         
-        # Check each parameter in the handler signature
-        for param_name, param in 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
+        
+        # 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 +268,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,
@@ -157,71 +299,164 @@ def create_enhanced_handler(original_handler, route_definition):
     1. Parses JSON body automatically using Satya validation
     2. Normalizes responses (supports tuple returns)
     3. Provides better error messages
+    4. Properly handles both sync and async handlers
     
     Args:
         original_handler: The original Python handler function
         route_definition: RouteDefinition with metadata
         
     Returns:
-        Enhanced handler function
+        Enhanced handler function (async if original is async, sync otherwise)
     """
     sig = inspect.signature(original_handler)
+    is_async = inspect.iscoroutinefunction(original_handler)
     
-    def enhanced_handler(**kwargs):
-        """Enhanced handler with automatic body parsing."""
-        try:
-            # If there's a body in kwargs, parse it
-            if "body" in kwargs:
-                body_data = kwargs["body"]
-                
-                if body_data:  # Only parse if body is not empty
-                    parsed_body = RequestBodyParser.parse_json_body(
-                        body_data, 
-                        sig
-                    )
-                    # Merge parsed body params into kwargs
-                    kwargs.update(parsed_body)
-                
-                # Remove the raw body to avoid passing it to handler
-                kwargs.pop("body", None)
-            
-            # Remove headers if present
-            kwargs.pop("headers", None)
-            
-            # Filter kwargs to only pass expected parameters
-            filtered_kwargs = {
-                k: v for k, v in kwargs.items() 
-                if k in sig.parameters
-            }
-            
-            # Call original handler
-            if inspect.iscoroutinefunction(original_handler):
-                # For async handlers (future support)
-                result = original_handler(**filtered_kwargs)
-            else:
-                result = original_handler(**filtered_kwargs)
-            
-            # Normalize response
-            content, status_code = ResponseHandler.normalize_response(result)
-            
-            return ResponseHandler.format_json_response(content, status_code)
-            
-        except ValueError as e:
-            # Validation or parsing error (400 Bad Request)
-            return ResponseHandler.format_json_response(
-                {"error": "Bad Request", "detail": str(e)},
-                400
-            )
-        except Exception as e:
-            # Unexpected error (500 Internal Server Error)
-            import traceback
-            return ResponseHandler.format_json_response(
-                {
-                    "error": "Internal Server Error",
-                    "detail": str(e),
-                    "traceback": traceback.format_exc()
-                },
-                500
-            )
+    if is_async:
+        # Create async enhanced handler for async original handlers
+        async def enhanced_handler(**kwargs):
+            """Enhanced handler with automatic parsing of body, query params, path params, and headers."""
+            try:
+                parsed_params = {}
+                
+                # 1. Parse query parameters
+                if "query_string" in kwargs:
+                    query_string = kwargs.get("query_string", "")
+                    if query_string:
+                        query_params = QueryParamParser.parse_query_params(query_string)
+                        parsed_params.update(query_params)
+                
+                # 2. Parse path parameters (if route pattern is available)
+                if "path" in kwargs and hasattr(route_definition, 'path'):
+                    actual_path = kwargs.get("path", "")
+                    route_pattern = route_definition.path
+                    if actual_path and route_pattern:
+                        path_params = PathParamParser.extract_path_params(route_pattern, actual_path)
+                        parsed_params.update(path_params)
+                
+                # 3. Parse headers
+                if "headers" in kwargs:
+                    headers_dict = kwargs.get("headers", {})
+                    if headers_dict:
+                        header_params = HeaderParser.parse_headers(headers_dict, sig)
+                        parsed_params.update(header_params)
+                
+                # 4. Parse request body (JSON)
+                if "body" in kwargs:
+                    body_data = kwargs["body"]
+                    
+                    if body_data:  # Only parse if body is not empty
+                        parsed_body = RequestBodyParser.parse_json_body(
+                            body_data, 
+                            sig
+                        )
+                        # Merge parsed body params (body params take precedence)
+                        parsed_params.update(parsed_body)
+                
+                # Filter to only pass expected parameters
+                filtered_kwargs = {
+                    k: v for k, v in parsed_params.items() 
+                    if k in sig.parameters
+                }
+                
+                # Call original async handler and await it
+                result = await original_handler(**filtered_kwargs)
+                
+                # Normalize response
+                content, status_code = ResponseHandler.normalize_response(result)
+                
+                return ResponseHandler.format_json_response(content, status_code)
+                
+            except ValueError as e:
+                # Validation or parsing error (400 Bad Request)
+                return ResponseHandler.format_json_response(
+                    {"error": "Bad Request", "detail": str(e)},
+                    400
+                )
+            except Exception as e:
+                # Unexpected error (500 Internal Server Error)
+                import traceback
+                return ResponseHandler.format_json_response(
+                    {
+                        "error": "Internal Server Error",
+                        "detail": str(e),
+                        "traceback": traceback.format_exc()
+                    },
+                    500
+                )
+        
+        return enhanced_handler
     
-    return enhanced_handler
+    else:
+        # Create sync enhanced handler for sync original handlers
+        def enhanced_handler(**kwargs):
+            """Enhanced handler with automatic parsing of body, query params, path params, and headers."""
+            try:
+                parsed_params = {}
+                
+                # 1. Parse query parameters
+                if "query_string" in kwargs:
+                    query_string = kwargs.get("query_string", "")
+                    if query_string:
+                        query_params = QueryParamParser.parse_query_params(query_string)
+                        parsed_params.update(query_params)
+                
+                # 2. Parse path parameters (if route pattern is available)
+                if "path" in kwargs and hasattr(route_definition, 'path'):
+                    actual_path = kwargs.get("path", "")
+                    route_pattern = route_definition.path
+                    if actual_path and route_pattern:
+                        path_params = PathParamParser.extract_path_params(route_pattern, actual_path)
+                        parsed_params.update(path_params)
+                
+                # 3. Parse headers
+                if "headers" in kwargs:
+                    headers_dict = kwargs.get("headers", {})
+                    if headers_dict:
+                        header_params = HeaderParser.parse_headers(headers_dict, sig)
+                        parsed_params.update(header_params)
+                
+                # 4. Parse request body (JSON)
+                if "body" in kwargs:
+                    body_data = kwargs["body"]
+                    
+                    if body_data:  # Only parse if body is not empty
+                        parsed_body = RequestBodyParser.parse_json_body(
+                            body_data, 
+                            sig
+                        )
+                        # Merge parsed body params (body params take precedence)
+                        parsed_params.update(parsed_body)
+                
+                # Filter to only pass expected parameters
+                filtered_kwargs = {
+                    k: v for k, v in parsed_params.items() 
+                    if k in sig.parameters
+                }
+                
+                # Call original sync handler
+                result = original_handler(**filtered_kwargs)
+                
+                # Normalize response
+                content, status_code = ResponseHandler.normalize_response(result)
+                
+                return ResponseHandler.format_json_response(content, status_code)
+                
+            except ValueError as e:
+                # Validation or parsing error (400 Bad Request)
+                return ResponseHandler.format_json_response(
+                    {"error": "Bad Request", "detail": str(e)},
+                    400
+                )
+            except Exception as e:
+                # Unexpected error (500 Internal Server Error)
+                import traceback
+                return ResponseHandler.format_json_response(
+                    {
+                        "error": "Internal Server Error",
+                        "detail": str(e),
+                        "traceback": traceback.format_exc()
+                    },
+                    500
+                )
+        
+        return enhanced_handler

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.15.dist-info}/METADATA

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

{turboapi-0.4.12.dist-info → turboapi-0.4.15.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=tZ3VAZ5HuUzziFCJ2lDsDJnJO-xy4omAQIa7TJCFCZk,96
+turboapi-0.4.15.dist-info/METADATA,sha256=4_skH-GqtS3RKpgwaT13pcN7nNKWCH_6TK84i0A6gQw,1482
+turboapi-0.4.15.dist-info/WHEEL,sha256=tZ3VAZ5HuUzziFCJ2lDsDJnJO-xy4omAQIa7TJCFCZk,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=ymAuJushPEyUUMpyolTp70cn3mvjSF3Et5hPtdMoZYk,18642
 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.cp314-win_amd64.pyd,sha256=a4_Rd0h6Mvi4S2m0bw9-8q1fcagh7ptwb1Z5nxdvn00,3664384
+turboapi/turbonet.cp314-win_amd64.pyd,sha256=GF_oeKq8Lm8dU_LJpqvq51Jo5n_uWzuPdp5GB8f-DrY,3681280
 turboapi/version_check.py,sha256=z3O1vIJsWmG_DO271ayYWSwaDfgpFnfJzYRYyowKYMc,9625
-turboapi-0.4.12.dist-info/RECORD,,
+turboapi-0.4.15.dist-info/RECORD,,