turboapi 0.4.13__cp313-cp313-win_amd64.whl → 0.4.15__cp313-cp313-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."""
     
@@ -207,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 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 = {}
                 
-                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)
+                # 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)
                 
-                # 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
-            )
+                # 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-0.4.13.dist-info → turboapi-0.4.15.dist-info}/METADATA

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

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

@@ -1,5 +1,5 @@
-turboapi-0.4.13.dist-info/METADATA,sha256=Cx_c3TzPTzH999Vc5NxdbruBeIuVIISBgN1xXWMVNdM,1482
-turboapi-0.4.13.dist-info/WHEEL,sha256=TJQY77QRLvXq32tEs9ATmwKO6NAOtuKOAw50eyiSmWU,96
+turboapi-0.4.15.dist-info/METADATA,sha256=4_skH-GqtS3RKpgwaT13pcN7nNKWCH_6TK84i0A6gQw,1482
+turboapi-0.4.15.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=xS9b6HqAGUDRp8D4O09i6jhxmw56771DfvjhRHaMDwU,10752
+turboapi/request_handler.py,sha256=ymAuJushPEyUUMpyolTp70cn3mvjSF3Et5hPtdMoZYk,18642
 turboapi/routing.py,sha256=iCbty56a2J9qnCtxIHQtYf66ZoKVxgISxwCxYvGmgEs,7746
 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=cIBGcGkdVilk6CEYDc_zD5QatdYSiAWOYyNrG9oBFcw,3664384
+turboapi/turbonet.cp313-win_amd64.pyd,sha256=ui6NpZqTnmPAIYUs1Y0BQoCIIWZr-18i-VFSay2dQAk,3688448
 turboapi/version_check.py,sha256=z3O1vIJsWmG_DO271ayYWSwaDfgpFnfJzYRYyowKYMc,9625
-turboapi-0.4.13.dist-info/RECORD,,
+turboapi-0.4.15.dist-info/RECORD,,