turboapi 0.5.2__cp313-cp313-win_amd64.whl → 0.5.22__cp313-cp313-win_amd64.whl

turboapi/request_handler.py

@@ -229,9 +229,12 @@ class RequestBodyParser:
         """
         if not body:
             return {}
-            
+
         try:
-            json_data = json.loads(body.decode('utf-8'))
+            # CRITICAL: Make a defensive copy immediately using bytearray to force real copy
+            # Free-threaded Python with Metal/MLX can have concurrent memory access issues
+            body_copy = bytes(bytearray(body))
+            json_data = json.loads(body_copy.decode('utf-8'))
         except (json.JSONDecodeError, UnicodeDecodeError) as e:
             raise ValueError(f"Invalid JSON body: {e}")
         
@@ -316,6 +319,25 @@ class RequestBodyParser:
         return parsed_params
 
 
+def _is_binary_content_type(content_type: str) -> bool:
+    """Check if the content type indicates binary data."""
+    if not content_type:
+        return False
+    ct_lower = content_type.lower()
+    # Binary content types that should not be JSON serialized
+    binary_prefixes = (
+        'audio/',
+        'video/',
+        'image/',
+        'application/octet-stream',
+        'application/pdf',
+        'application/zip',
+        'application/gzip',
+        'application/x-tar',
+    )
+    return ct_lower.startswith(binary_prefixes)
+
+
 class ResponseHandler:
     """Handle different response formats including FastAPI-style tuples."""
     
@@ -336,22 +358,36 @@ class ResponseHandler:
             result: Raw result from handler
 
         Returns:
-            Tuple of (content, status_code)
+            Tuple of (content, status_code) or (content, status_code, content_type)
         """
         # Handle Response objects (JSONResponse, HTMLResponse, etc.)
         from turboapi.responses import Response
         if isinstance(result, Response):
             # Extract content from Response object
             body = result.body
+            content_type = result.media_type
+
+            # For binary content types, return raw bytes
+            if content_type and _is_binary_content_type(content_type):
+                # Return raw bytes with content_type for binary responses
+                return body, result.status_code, content_type
+
             if isinstance(body, bytes):
                 # Try to decode as JSON for JSONResponse
                 try:
                     import json
                     body = json.loads(body.decode('utf-8'))
-                except (json.JSONDecodeError, UnicodeDecodeError):
-                    # Keep as string for HTML/Text responses
-                    body = body.decode('utf-8')
-            return body, result.status_code
+                except json.JSONDecodeError:
+                    # Not JSON, try as plain text
+                    try:
+                        body = body.decode('utf-8')
+                    except UnicodeDecodeError:
+                        # Binary data - return with content_type
+                        return body, result.status_code, content_type
+                except UnicodeDecodeError:
+                    # Binary data - return with content_type
+                    return body, result.status_code, content_type
+            return body, result.status_code, content_type
 
         # Handle tuple returns: (content, status_code)
         if isinstance(result, tuple):
@@ -375,25 +411,42 @@ class ResponseHandler:
         return result, 200
     
     @staticmethod
-    def format_json_response(content: Any, status_code: int) -> dict[str, Any]:
+    def format_response(content: Any, status_code: int, content_type: str | None = None) -> dict[str, Any]:
         """
-        Format content as JSON response.
-        
+        Format content as response. Handles both JSON and binary responses.
+
         Args:
-            content: Response content
+            content: Response content (can be dict, str, bytes, etc.)
             status_code: HTTP status code
-            
+            content_type: Optional content type (for binary responses)
+
         Returns:
             Dictionary with properly formatted response
         """
+        # For binary content (bytes with binary content_type), return directly
+        if isinstance(content, bytes) and content_type and _is_binary_content_type(content_type):
+            # Return bytes directly - Rust will handle as raw binary
+            return {
+                "content": content,  # Keep as bytes for Rust to extract
+                "status_code": status_code,
+                "content_type": content_type
+            }
+
         # Handle Satya models
         if isinstance(content, Model):
             content = content.model_dump()
-        
+
         # Recursively convert any nested Satya models in dicts/lists
         def make_serializable(obj):
             if isinstance(obj, Model):
                 return obj.model_dump()
+            elif isinstance(obj, bytes):
+                # Non-binary bytes - try to decode as UTF-8, otherwise base64 encode
+                try:
+                    return obj.decode('utf-8')
+                except UnicodeDecodeError:
+                    import base64
+                    return base64.b64encode(obj).decode('ascii')
             elif isinstance(obj, dict):
                 return {k: make_serializable(v) for k, v in obj.items()}
             elif isinstance(obj, (list, tuple)):
@@ -403,15 +456,20 @@ class ResponseHandler:
             else:
                 # Try to convert to string for unknown types
                 return str(obj)
-        
+
         content = make_serializable(content)
-        
+
         return {
             "content": content,
             "status_code": status_code,
-            "content_type": "application/json"
+            "content_type": content_type or "application/json"
         }
 
+    @staticmethod
+    def format_json_response(content: Any, status_code: int, content_type: str | None = None) -> dict[str, Any]:
+        """Alias for format_response for backwards compatibility."""
+        return ResponseHandler.format_response(content, status_code, content_type)
+
 
 def create_enhanced_handler(original_handler, route_definition):
     """
@@ -491,11 +549,16 @@ def create_enhanced_handler(original_handler, route_definition):
 
                 # 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)
+
+                # Normalize response - may return (content, status) or (content, status, content_type)
+                normalized = ResponseHandler.normalize_response(result)
+                if len(normalized) == 3:
+                    content, status_code, content_type = normalized
+                else:
+                    content, status_code = normalized
+                    content_type = None
+
+                return ResponseHandler.format_json_response(content, status_code, content_type)
                 
             except ValueError as e:
                 # Validation or parsing error (400 Bad Request)
@@ -575,11 +638,16 @@ def create_enhanced_handler(original_handler, route_definition):
 
                 # 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)
+
+                # Normalize response - may return (content, status) or (content, status, content_type)
+                normalized = ResponseHandler.normalize_response(result)
+                if len(normalized) == 3:
+                    content, status_code, content_type = normalized
+                else:
+                    content, status_code = normalized
+                    content_type = None
+
+                return ResponseHandler.format_json_response(content, status_code, content_type)
                 
             except ValueError as e:
                 # Validation or parsing error (400 Bad Request)

turboapi/rust_integration.py

@@ -43,6 +43,10 @@ def classify_handler(handler, route) -> tuple[str, dict[str, str], dict]:
             if BaseModel is not None and inspect.isclass(annotation) and issubclass(annotation, BaseModel):
                 # Found a model parameter - use fast model path (sync only for now)
                 model_info = {"param_name": param_name, "model_class": annotation}
+                # For async handlers, model parsing needs the enhanced path
+                # since Rust-side model parsing only supports sync handlers
+                if is_async:
+                    needs_body = True
                 continue  # Don't add to param_types
         except TypeError:
             pass

{turboapi-0.5.2.dist-info → turboapi-0.5.22.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: turboapi
-Version: 0.5.2
+Version: 0.5.22
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
@@ -33,7 +33,7 @@ Project-URL: Homepage, https://github.com/justrach/turboAPI
 Project-URL: Repository, https://github.com/justrach/turboAPI
 
 <p align="center">
-  <img src="assets/architecture.png" alt="TurboAPI Architecture" width="600"/>
+  <img src="assets/turbito.png" alt="Turbito - TurboAPI Mascot" width="260"/>
 </p>
 
 <h1 align="center">TurboAPI</h1>
@@ -42,6 +42,10 @@ Project-URL: Repository, https://github.com/justrach/turboAPI
   <strong>The FastAPI you know. The speed you deserve.</strong>
 </p>
 
+<p align="center">
+  <em>Meet Turbito — the tiny Rust-powered engine that makes your FastAPI fly.</em>
+</p>
+
 <p align="center">
   <a href="https://pypi.org/project/turboapi/"><img src="https://img.shields.io/pypi/v/turboapi.svg" alt="PyPI version"></a>
   <a href="https://github.com/justrach/turboAPI/blob/main/LICENSE"><img src="https://img.shields.io/badge/license-MIT-blue.svg" alt="License"></a>
@@ -52,10 +56,10 @@ Project-URL: Repository, https://github.com/justrach/turboAPI
 <p align="center">
   <a href="#the-problem">The Problem</a> •
   <a href="#the-solution">The Solution</a> •
+  <a href="#meet-turbito">Meet Turbito</a> •
   <a href="#quick-start">Quick Start</a> •
-  <a href="#benchmarks">Benchmarks</a> •
-  <a href="#async-support">Async Support</a> •
-  <a href="#migration-guide">Migration Guide</a>
+  <a href="#whats-new">What's New</a> •
+  <a href="#benchmarks">Benchmarks</a>
 </p>
 
 ---
@@ -99,6 +103,46 @@ The result? Your existing FastAPI code runs faster without changing a single lin
 
 ---
 
+## Meet Turbito
+
+<p align="center">
+  <img src="assets/turbito.png" alt="Turbito" width="180"/>
+</p>
+
+Turbito is the little engine inside TurboAPI.
+
+While you write normal FastAPI code, Turbito is:
+- Parsing HTTP in Rust (Hyper/Tokio)
+- Serializing JSON with SIMD acceleration
+- Scheduling async work with Tokio's work-stealing scheduler
+- Dodging the GIL like a speed demon
+
+You never see Turbito. You just feel the speed.
+
+---
+
+## What's New
+
+### v0.5.21 — Free-Threading Stability Release
+
+This release fixes critical issues when running with **free-threaded Python (3.13t)** and **Metal/MLX GPU frameworks**:
+
+| Fix | Description |
+|-----|-------------|
+| **Memory Corruption** | Fixed race condition where request body bytes were corrupted when using async handlers with MLX models loaded |
+| **Response Serialization** | Response objects now properly serialize their content instead of string representation |
+| **Async BaseModel** | Async handlers with BaseModel parameters now correctly receive the validated model instance |
+| **JSON Parsing** | Added Python fallback for edge cases where simd-json is too strict |
+
+**Technical Deep Dive:** When running free-threaded Python with Metal GPU frameworks, memory can be accessed concurrently by the CPU and GPU. We now use defensive copying (`PyBytes::new()` in Rust, `bytes(bytearray())` in Python) to ensure request data is isolated before processing.
+
+```bash
+# Upgrade to get the fixes
+pip install --upgrade turboapi
+```
+
+---
+
 ## Quick Start
 
 ### Installation
@@ -149,15 +193,15 @@ app.run()
 
 Async handlers are automatically detected and routed through Tokio's work-stealing scheduler for optimal concurrency.
 
-### For Maximum Performance
+### Let Turbito Off the Leash
 
-Run with Python's free-threading mode:
+For maximum performance, run with Python's free-threading mode:
 
 ```bash
 PYTHON_GIL=0 python app.py
 ```
 
-This unlocks the full power of TurboAPI's Rust core by removing the GIL bottleneck.
+This unlocks Turbito's full power by removing the GIL bottleneck. True parallelism, finally.
 
 ---
 
@@ -340,6 +384,7 @@ Everything you use in FastAPI works in TurboAPI:
 | GZip middleware | ✅ | Configurable |
 | Background tasks | ✅ | Async-compatible |
 | WebSocket | ✅ | HTTP upgrade support |
+| HTTP/2 | ✅ | With server push |
 | APIRouter | ✅ | Prefixes and tags |
 | HTTPException | ✅ | With custom headers |
 | Custom responses | ✅ | JSON, HTML, Redirect, etc. |
@@ -420,7 +465,7 @@ app.add_middleware(GZipMiddleware, minimum_size=1000)
 
 ## Architecture
 
-TurboAPI's secret is a hybrid architecture:
+TurboAPI's secret is a hybrid architecture where Python meets Rust:
 
 ```
 ┌──────────────────────────────────────────────────────────┐
@@ -494,10 +539,10 @@ python tests/benchmark_comparison.py
 - [x] Handler classification for optimized fast paths
 - [x] **Async handler optimization (Tokio + pyo3-async-runtimes)**
 - [x] **WebSocket HTTP upgrade support**
+- [x] **HTTP/2 with server push**
 
 ### In Progress 🚧
 
-- [ ] HTTP/2 with server push
 - [ ] OpenAPI/Swagger auto-generation
 
 ### Planned 📋
@@ -525,7 +570,8 @@ MIT License. Use it, modify it, ship it.
 ---
 
 <p align="center">
-  <strong>Stop waiting for Python to be fast. Make it fast.</strong>
+  <strong>Built for developers who love FastAPI.</strong><br/>
+  <em>Powered by Turbito ⚡</em>
 </p>
 
 <p align="center">

{turboapi-0.5.2.dist-info → turboapi-0.5.22.dist-info}/RECORD

@@ -10,20 +10,20 @@ turboapi\main_app.py,sha256=27MWIQaJKfNEUnkjSbGR76E0GNlJk-P4ZqokUAH1j4I,13780
 turboapi\middleware.py,sha256=xmuzCm07OIdEtMI_PJcrE5GQg7l0PfQTLEbIbZnuJSE,11077
 turboapi\models.py,sha256=LxWzSy3GXl9BvI8j6hsX4XuQRrspFyLfg4lwi-kwuPE,4606
 turboapi\openapi.py,sha256=sn5KpV_-50OJZv5NM8pWpLrjmb0abFg9k2sSDMZz5Fs,7517
-turboapi\request_handler.py,sha256=4MSekNk2upQVAdySjIK18NV5RfSCcdqUcwIUtaZJVCE,24370
+turboapi\request_handler.py,sha256=TZas04Vf8jKoNi_4TJ_-McuB6YWiIYfOdOtekKRe-U8,27643
 turboapi\responses.py,sha256=Ry64gbK993s0LUf3jgdBAAAMAnR_6d-o8EDPCAv3vqQ,6261
 turboapi\routing.py,sha256=mZdDBQqKOfIvPJrLplKrC3sEqqic79qPEMFl0Iw0ugM,7821
-turboapi\rust_integration.py,sha256=pn5q_AvVQw27lwxHko5y7-iE51GtL1c_YT5XrrfKD0g,15695
+turboapi\rust_integration.py,sha256=TfP4zOqE4NOUlVr_Lheu6apQ5cZVx2JWJ0kvGHF-nf8,15918
 turboapi\security.py,sha256=KBzyDkF8CN9-hOEUoRRBTqG0Zc1OtwI7aFInDJYusLM,18064
 turboapi\server_integration.py,sha256=drUhhTasWgQfyhFiAaHKd987N3mnE0qkMab1ylmqd4c,18340
 turboapi\staticfiles.py,sha256=w_y4cw0ncYjdO8kZN_LZz5rQ5Iz8OE7TiWBtgAeBZGo,2952
 turboapi\status.py,sha256=MT9i17mLjksTnX3d5Vr7Wt1M6GVj5SsQ78p1XktRWvQ,3153
 turboapi\templating.py,sha256=0UKtBLA-MQNutwFOV8sy7gIOLy94dsAQnpkIb4GrBnw,2160
 turboapi\testclient.py,sha256=g4gm-Nj84JjMPk90Y1TDjZ7sKXzn_Mcf0XrEQvHyU-k,10990
-turboapi\turbonet.cp313-win_amd64.pyd,sha256=oqQGb6MefZ2cWcQFSEuxCfsKBueal9-Rju38SxH7Me0,5146624
+turboapi\turbonet.cp313-win_amd64.pyd,sha256=UhBl_GDjmp8igWn4M33W962BxzJBEncOuk7eZWMH95Y,5170688
 turboapi\version_check.py,sha256=z3O1vIJsWmG_DO271ayYWSwaDfgpFnfJzYRYyowKYMc,9625
 turboapi\websockets.py,sha256=FV3tcCXKutgnkkmyJCdTVgGB5eNBLHT3MBPmXAx9Rzk,4356
-turboapi-0.5.2.dist-info\METADATA,sha256=_G7zPH9sdzWImSQgpuhpJJDEFDTg-XHQUrpqcFmHejA,18054
-turboapi-0.5.2.dist-info\WHEEL,sha256=n_BmF69IyGtioVWE9c3M_zsEfe6-xMZy1v5HCL_6qE0,97
-turboapi-0.5.2.dist-info\licenses\LICENSE,sha256=BcaHZdCsG_B-lpQab7W63JiSB8wlewkjk9i1MXss26A,1088
-turboapi-0.5.2.dist-info\RECORD,,
+turboapi-0.5.22.dist-info\METADATA,sha256=xHSztJU9mw1yio4v4MN23XDBbCqeewD_xRFw5I25W30,19814
+turboapi-0.5.22.dist-info\WHEEL,sha256=n_BmF69IyGtioVWE9c3M_zsEfe6-xMZy1v5HCL_6qE0,97
+turboapi-0.5.22.dist-info\licenses\LICENSE,sha256=BcaHZdCsG_B-lpQab7W63JiSB8wlewkjk9i1MXss26A,1088
+turboapi-0.5.22.dist-info\RECORD,,