turboapi 0.4.16__cp313-cp313-macosx_10_12_x86_64.whl → 0.5.21__cp313-cp313-macosx_10_12_x86_64.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}")
         
@@ -348,9 +351,16 @@ class ResponseHandler:
                 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')
+                except json.JSONDecodeError:
+                    # Not JSON, try as plain text
+                    try:
+                        body = body.decode('utf-8')
+                    except UnicodeDecodeError:
+                        # Binary data (audio, image, etc.) - keep as bytes
+                        pass
+                except UnicodeDecodeError:
+                    # Binary data (audio, image, etc.) - keep as bytes
+                    pass
             return body, result.status_code
 
         # Handle tuple returns: (content, status_code)
@@ -394,6 +404,13 @@ class ResponseHandler:
         def make_serializable(obj):
             if isinstance(obj, Model):
                 return obj.model_dump()
+            elif isinstance(obj, bytes):
+                # Binary data - 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)):
@@ -491,7 +508,7 @@ 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)
                 

turboapi/rust_integration.py

@@ -20,16 +20,15 @@ from .version_check import CHECK_MARK, CROSS_MARK, ROCKET
 
 
 def classify_handler(handler, route) -> tuple[str, dict[str, str], dict]:
-    """Classify a handler for fast dispatch (Phase 3).
+    """Classify a handler for fast dispatch (Phase 3 + Phase 4 async).
 
     Returns:
         (handler_type, param_types, model_info) where:
-        - handler_type: "simple_sync" | "body_sync" | "model_sync" | "enhanced"
+        - handler_type: "simple_sync" | "body_sync" | "model_sync" | "simple_async" | "body_async" | "enhanced"
         - param_types: dict mapping param_name -> type hint string
         - model_info: dict with "param_name" and "model_class" for model handlers
     """
-    if inspect.iscoroutinefunction(handler):
-        return "enhanced", {}, {}
+    is_async = inspect.iscoroutinefunction(handler)
 
     sig = inspect.signature(handler)
     param_types = {}
@@ -42,8 +41,12 @@ def classify_handler(handler, route) -> tuple[str, dict[str, str], dict]:
         # Check for dhi/Pydantic BaseModel
         try:
             if BaseModel is not None and inspect.isclass(annotation) and issubclass(annotation, BaseModel):
-                # Found a model parameter - use fast model path
+                # 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
@@ -64,13 +67,23 @@ def classify_handler(handler, route) -> tuple[str, dict[str, str], dict]:
         elif annotation is str or annotation is inspect.Parameter.empty:
             param_types[param_name] = "str"
 
-    # Model handlers use fast model path (simd-json + model_validate)
-    if model_info:
-        method = route.method.value.upper() if hasattr(route, "method") else "GET"
+    method = route.method.value.upper() if hasattr(route, "method") else "GET"
+
+    # Model handlers use fast model path (simd-json + model_validate) - sync only
+    if model_info and not is_async:
         if method in ("POST", "PUT", "PATCH", "DELETE"):
             return "model_sync", param_types, model_info
 
-    method = route.method.value.upper() if hasattr(route, "method") else "GET"
+    # Async handlers - Phase 4 async fast paths via Tokio
+    if is_async:
+        if method in ("POST", "PUT", "PATCH", "DELETE"):
+            if needs_body:
+                # Complex body types still need enhanced path
+                return "enhanced", param_types, {}
+            return "body_async", param_types, {}
+        return "simple_async", param_types, {}
+
+    # Sync handlers - Phase 3 sync fast paths
     if method in ("POST", "PUT", "PATCH", "DELETE"):
         if needs_body:
             return "enhanced", param_types, {}
@@ -207,8 +220,7 @@ class RustIntegratedTurboAPI(TurboAPI):
                     )
                     print(f"{CHECK_MARK} [model_sync] {route.method.value} {route.path}")
                 elif handler_type in ("simple_sync", "body_sync"):
-                    # FAST PATH: Register with metadata for Rust-side parsing
-                    # Enhanced handler is fallback, original handler is for direct call
+                    # SYNC FAST PATH: Register with metadata for Rust-side parsing
                     enhanced_handler = create_enhanced_handler(route.handler, route)
                     param_types_json = json.dumps(param_types)
 
@@ -221,6 +233,20 @@ class RustIntegratedTurboAPI(TurboAPI):
                         route.handler,  # Original unwrapped handler
                     )
                     print(f"{CHECK_MARK} [{handler_type}] {route.method.value} {route.path}")
+                elif handler_type in ("simple_async", "body_async"):
+                    # ASYNC FAST PATH: Register with Tokio async runtime
+                    enhanced_handler = create_enhanced_handler(route.handler, route)
+                    param_types_json = json.dumps(param_types)
+
+                    self.rust_server.add_route_async_fast(
+                        route.method.value,
+                        route.path,
+                        enhanced_handler,  # Fallback wrapper
+                        handler_type,
+                        param_types_json,
+                        route.handler,  # Original async handler
+                    )
+                    print(f"{CHECK_MARK} [{handler_type}] {route.method.value} {route.path}")
                 else:
                     # ENHANCED PATH: Full Python wrapper needed
                     enhanced_handler = create_enhanced_handler(route.handler, route)

{turboapi-0.4.16.dist-info → turboapi-0.5.21.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: turboapi
-Version: 0.4.16
+Version: 0.5.21
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
@@ -11,7 +11,7 @@ Classifier: Programming Language :: Rust
 Classifier: Topic :: Internet :: WWW/HTTP :: HTTP Servers
 Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
 Classifier: Framework :: FastAPI
-Requires-Dist: dhi>=1.1.3
+Requires-Dist: dhi>=1.1.15
 Requires-Dist: matplotlib>=3.5.0 ; extra == 'benchmark'
 Requires-Dist: requests>=2.25.0 ; extra == 'benchmark'
 Requires-Dist: pytest>=7.0.0 ; extra == 'dev'
@@ -42,11 +42,19 @@ Project-URL: Repository, https://github.com/justrach/turboAPI
   <strong>The FastAPI you know. The speed you deserve.</strong>
 </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>
+  <a href="https://www.python.org/downloads/"><img src="https://img.shields.io/badge/python-3.13+-blue.svg" alt="Python 3.13+"></a>
+  <a href="https://deepwiki.com/justrach/turboAPI"><img src="https://deepwiki.com/badge.svg" alt="Ask DeepWiki"></a>
+</p>
+
 <p align="center">
   <a href="#the-problem">The Problem</a> •
   <a href="#the-solution">The Solution</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>
 </p>
 
@@ -64,7 +72,7 @@ You've optimized your database queries. Added caching. Switched to async. Still
 
 ## The Solution
 
-**TurboAPI** is FastAPI with a Rust-powered engine. Same API. Same syntax. 2-3x faster.
+**TurboAPI** is FastAPI with a Rust-powered engine. Same API. Same syntax. **1.3-1.8x faster**.
 
 ```python
 # This is all you change
@@ -82,9 +90,10 @@ Everything else stays exactly the same.
 | What FastAPI Does | What TurboAPI Does | Speedup |
 |-------------------|-------------------|---------|
 | HTTP parsing in Python | HTTP parsing in Rust (Hyper/Tokio) | 3x |
-| JSON with `json.dumps()` | JSON with SIMD-accelerated Rust | 2x |
+| JSON with `json.dumps()` | SIMD-accelerated JSON (simd-json) | 2x |
 | GIL-bound threading | Python 3.13 free-threading | 2x |
 | dict-based routing | Radix tree with O(log n) lookup | 1.5x |
+| Async via asyncio | Async via Tokio work-stealing | 1.2x |
 
 The result? Your existing FastAPI code runs faster without changing a single line of business logic.
 
@@ -116,6 +125,30 @@ app.run()
 
 That's it. Your first TurboAPI server is running at `http://localhost:8000`.
 
+### Async Handlers (New!)
+
+TurboAPI now supports **true async** with Tokio-powered execution:
+
+```python
+from turboapi import TurboAPI
+import asyncio
+
+app = TurboAPI()
+
+@app.get("/sync")
+def sync_handler():
+    return {"type": "sync", "message": "Fast!"}
+
+@app.get("/async")
+async def async_handler():
+    await asyncio.sleep(0.001)  # Simulated I/O
+    return {"type": "async", "message": "Even faster under load!"}
+
+app.run()
+```
+
+Async handlers are automatically detected and routed through Tokio's work-stealing scheduler for optimal concurrency.
+
 ### For Maximum Performance
 
 Run with Python's free-threading mode:
@@ -132,9 +165,18 @@ This unlocks the full power of TurboAPI's Rust core by removing the GIL bottlene
 
 Real numbers matter. Here's TurboAPI vs FastAPI on identical hardware:
 
-<p align="center">
-  <img src="assets/benchmark_throughput.png" alt="Throughput Comparison" width="800"/>
-</p>
+### Latest Benchmark Results
+
+| Endpoint | TurboAPI | FastAPI | Improvement |
+|----------|----------|---------|-------------|
+| **Sequential Latency** |
+| GET / | 0.76ms | 1.05ms | **1.4x faster** |
+| GET /benchmark/simple | 0.61ms | 0.81ms | **1.3x faster** |
+| GET /benchmark/medium | 0.61ms | 0.77ms | **1.3x faster** |
+| GET /benchmark/json | 0.72ms | 1.04ms | **1.4x faster** |
+| **Concurrent Latency** |
+| GET / | 2.05ms | 2.53ms | **1.2x faster** |
+| GET /benchmark/json | 2.17ms | 3.90ms | **1.8x faster** |
 
 ### Throughput (requests/second)
 
@@ -144,34 +186,89 @@ Real numbers matter. Here's TurboAPI vs FastAPI on identical hardware:
 | GET /json (object) | **20,592** | 7,882 | 2.6x |
 | GET /users/{id} (path params) | **18,428** | 7,344 | 2.5x |
 | POST /items (model validation) | **19,255** | 6,312 | **3.1x** |
-| GET /status201 (custom status) | **15,698** | 8,608 | 1.8x |
-
-### Latency (lower is better)
 
-<p align="center">
-  <img src="assets/benchmark_latency.png" alt="Latency Comparison" width="800"/>
-</p>
+### Async Handler Performance
 
-| Endpoint | TurboAPI (avg/p99) | FastAPI (avg/p99) |
-|----------|-------------------|-------------------|
-| GET / | 5.1ms / 11.6ms | 12.0ms / 18.6ms |
-| GET /json | 4.9ms / 11.8ms | 12.7ms / 17.6ms |
-| POST /items | **5.3ms / 13.1ms** | 16.2ms / 43.9ms |
+| Metric | Sync Handler | Async Handler | Notes |
+|--------|--------------|---------------|-------|
+| Sequential (100 req) | 0.66ms | 0.76ms | Similar performance |
+| Concurrent (200 req) | 108ms batch | 139ms batch | Sync faster for CPU-bound |
+| I/O Wait (1ms sleep) | 2.22ms | 2.06ms | **Async wins for I/O** |
 
-*Benchmarked with wrk, 4 threads, 100 connections, 10 seconds. Python 3.13t free-threading mode.*
+**Key Insight:** Use async handlers when you have actual I/O operations (database, network). For pure CPU work, sync handlers are slightly faster.
 
 ### Run Your Own Benchmarks
 
 ```bash
-# Install wrk (macOS)
-brew install wrk
+# Quick benchmark
+python benches/python_benchmark.py
 
-# Run the benchmark suite
-pip install matplotlib  # for charts
-PYTHON_GIL=0 python benchmarks/run_benchmarks.py
+# Full comparison with FastAPI
+python tests/benchmark_comparison.py
 
-# Generate charts
-python benchmarks/generate_charts.py
+# Async vs Sync comparison
+python benches/async_comparison_bench.py
+```
+
+---
+
+## Async Support
+
+### How Async Works in TurboAPI
+
+TurboAPI uses a **hybrid async architecture**:
+
+```
+┌─────────────────────────────────────────────────────────┐
+│                Your Python Handlers                      │
+│         @app.get("/sync")      @app.get("/async")       │
+│         def handler():         async def handler():     │
+├─────────────────────────────────────────────────────────┤
+│              Handler Classification                      │
+│   simple_sync │ body_sync │ simple_async │ body_async  │
+├─────────────────────────────────────────────────────────┤
+│              Tokio Runtime (Rust)                        │
+│         Work-stealing scheduler • 14 workers            │
+├─────────────────────────────────────────────────────────┤
+│              pyo3-async-runtimes                         │
+│     Python coroutines ↔ Rust futures conversion         │
+└─────────────────────────────────────────────────────────┘
+```
+
+### Handler Types
+
+TurboAPI automatically classifies handlers for optimal dispatch:
+
+| Handler Type | Description | Use Case |
+|--------------|-------------|----------|
+| `simple_sync` | Sync, no body | GET endpoints |
+| `body_sync` | Sync, with body | POST/PUT without complex types |
+| `model_sync` | Sync, with model validation | POST with dhi models |
+| `simple_async` | Async, no body | GET with I/O operations |
+| `body_async` | Async, with body | POST/PUT with I/O operations |
+| `enhanced` | Full Python wrapper | Complex dependencies |
+
+### When to Use Async
+
+```python
+# Use sync for pure computation
+@app.get("/compute")
+def compute():
+    result = sum(i * i for i in range(1000))
+    return {"result": result}
+
+# Use async for I/O operations
+@app.get("/fetch-data")
+async def fetch_data():
+    async with aiohttp.ClientSession() as session:
+        async with session.get("https://api.example.com/data") as resp:
+            return await resp.json()
+
+# Use async for database operations
+@app.get("/users/{user_id}")
+async def get_user(user_id: int):
+    user = await database.fetch_one(query, values={"id": user_id})
+    return {"user": user}
 ```
 
 ---
@@ -234,6 +331,7 @@ Everything you use in FastAPI works in TurboAPI:
 | Query parameters | ✅ | With validation |
 | Request body (JSON) | ✅ | SIMD-accelerated |
 | Response models | ✅ | Full support |
+| **Async handlers** | ✅ | **Tokio-powered** |
 | Dependency injection | ✅ | `Depends()` with caching |
 | OAuth2 authentication | ✅ | Password & AuthCode flows |
 | HTTP Basic/Bearer auth | ✅ | Full implementation |
@@ -241,7 +339,7 @@ Everything you use in FastAPI works in TurboAPI:
 | CORS middleware | ✅ | Rust-accelerated |
 | GZip middleware | ✅ | Configurable |
 | Background tasks | ✅ | Async-compatible |
-| WebSocket | ✅ | Basic support |
+| WebSocket | ✅ | HTTP upgrade support |
 | APIRouter | ✅ | Prefixes and tags |
 | HTTPException | ✅ | With custom headers |
 | Custom responses | ✅ | JSON, HTML, Redirect, etc. |
@@ -266,6 +364,27 @@ def get_current_user(token: str = Depends(oauth2_scheme)):
     return {"user": "authenticated", "token": token}
 ```
 
+### Async Database Access
+
+```python
+from turboapi import TurboAPI
+import asyncpg
+
+app = TurboAPI()
+pool = None
+
+@app.on_event("startup")
+async def startup():
+    global pool
+    pool = await asyncpg.create_pool("postgresql://localhost/mydb")
+
+@app.get("/users/{user_id}")
+async def get_user(user_id: int):
+    async with pool.acquire() as conn:
+        row = await conn.fetchrow("SELECT * FROM users WHERE id = $1", user_id)
+        return dict(row) if row else {"error": "Not found"}
+```
+
 ### Request Validation
 
 ```python
@@ -297,47 +416,33 @@ app.add_middleware(
 app.add_middleware(GZipMiddleware, minimum_size=1000)
 ```
 
-### API Router
-
-```python
-from turboapi import APIRouter
-
-router = APIRouter(prefix="/api/v1", tags=["users"])
-
-@router.get("/users")
-def list_users():
-    return {"users": []}
-
-@router.get("/users/{user_id}")
-def get_user(user_id: int):
-    return {"user_id": user_id}
-
-app.include_router(router)
-```
-
 ---
 
-## How It Works
+## Architecture
 
 TurboAPI's secret is a hybrid architecture:
 
 ```
-┌──────────────────────────────────────────────────────┐
-│              Your Python Application                  │
-│         (exactly like FastAPI code)                   │
-├──────────────────────────────────────────────────────┤
-│       TurboAPI (FastAPI-compatible layer)            │
-│    Routing • Validation • Dependency Injection        │
-├──────────────────────────────────────────────────────┤
-│          PyO3 Bridge (zero-copy)                     │
-│     Rust ↔ Python with minimal overhead               │
-├──────────────────────────────────────────────────────┤
-│          TurboNet (Rust HTTP Core)                   │
-│  • Hyper + Tokio async runtime                       │
-│  • SIMD-accelerated JSON (simd-json)                 │
-│  • Radix tree routing                                │
-│  • Zero-copy response buffers                        │
-└──────────────────────────────────────────────────────┘
+┌──────────────────────────────────────────────────────────┐
+│              Your Python Application                      │
+│           (exactly like FastAPI code)                     │
+├──────────────────────────────────────────────────────────┤
+│         TurboAPI (FastAPI-compatible layer)              │
+│      Routing • Validation • Dependency Injection          │
+├──────────────────────────────────────────────────────────┤
+│           Handler Classification (Phase 3+4)             │
+│   simple_sync │ body_sync │ simple_async │ body_async   │
+├──────────────────────────────────────────────────────────┤
+│            PyO3 Bridge (zero-copy)                       │
+│       Rust ↔ Python with minimal overhead                 │
+├──────────────────────────────────────────────────────────┤
+│            TurboNet (Rust HTTP Core)                     │
+│   • Hyper + Tokio async runtime (14 worker threads)     │
+│   • SIMD-accelerated JSON (simd-json)                    │
+│   • Radix tree routing                                   │
+│   • Zero-copy response buffers                           │
+│   • pyo3-async-runtimes for async handler support       │
+└──────────────────────────────────────────────────────────┘
 ```
 
 **Python handles the logic you care about.** Routes, validation rules, business logic—all in Python.
@@ -369,6 +474,10 @@ pip install -e ./python
 
 # Run tests
 PYTHON_GIL=0 python -m pytest tests/ -v
+
+# Run benchmarks
+python benches/python_benchmark.py
+python tests/benchmark_comparison.py
 ```
 
 ---
@@ -383,20 +492,21 @@ PYTHON_GIL=0 python -m pytest tests/ -v
 - [x] FastAPI feature parity (OAuth2, Depends, Middleware)
 - [x] Radix tree routing with path parameters
 - [x] Handler classification for optimized fast paths
+- [x] **Async handler optimization (Tokio + pyo3-async-runtimes)**
+- [x] **WebSocket HTTP upgrade support**
 
 ### In Progress 🚧
 
-- [ ] Async handler optimization (pure Tokio)
-- [ ] WebSocket performance improvements
 - [ ] HTTP/2 with server push
+- [ ] OpenAPI/Swagger auto-generation
 
 ### Planned 📋
 
-- [ ] OpenAPI/Swagger auto-generation
 - [ ] GraphQL support
 - [ ] Database connection pooling
 - [ ] Prometheus metrics
 - [ ] Distributed tracing
+- [ ] gRPC support
 
 ---
 
@@ -404,6 +514,7 @@ PYTHON_GIL=0 python -m pytest tests/ -v
 
 - **Issues & Features**: [GitHub Issues](https://github.com/justrach/turboAPI/issues)
 - **Discussions**: [GitHub Discussions](https://github.com/justrach/turboAPI/discussions)
+- **Documentation**: [![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/justrach/turboAPI)
 
 ---
 

{turboapi-0.4.16.dist-info → turboapi-0.5.21.dist-info}/RECORD

@@ -10,20 +10,20 @@ turboapi/main_app.py,sha256=5w6x1DX_XChPCcZf24b4CC8qe24XFyGY3BRuR71qkCM,13411
 turboapi/middleware.py,sha256=3G5zhPKiHm07b_xv_dOsO88W1PfO78SGMySJe4d9nb4,10737
 turboapi/models.py,sha256=OzyDTEl97zcXa6DTrsR_hZZjj8Lr9QwsD0BrC74BE5o,4476
 turboapi/openapi.py,sha256=wwS4akekFns-OYQUh7bjKBzRqdg9Z7z5MFo27LlFkEY,7281
-turboapi/request_handler.py,sha256=aADbJdFQp5f3zzWD5fv0Jrtk6W46RzG7rGhlZrFL5tA,23768
+turboapi/request_handler.py,sha256=YHfJFqQJI_mZdczpARprOkpsNnCIojTrlW_vLgTdPQw,24593
 turboapi/responses.py,sha256=wiYkG53NNwXu1RDyRlZFF-8jxx51xL6LOTUj5TG__2c,6052
 turboapi/routing.py,sha256=-39IUSfsMswCLR-zJ6c4Ri0tYd7_UjYnQyioT4a1W_Q,7601
-turboapi/rust_integration.py,sha256=wvZzNJMDnkRMu-GRtItT9paZeMXSSfjCHcVbEuRiCzc,14251
+turboapi/rust_integration.py,sha256=StR_4PHIzz1Qk9T-MG5veu3qerwKohoXFeOagk6Be6E,15543
 turboapi/security.py,sha256=U2ZQSMWK9a6YzSk5F39TgeZriJ7JtDNZo3RldVPphKI,17493
 turboapi/server_integration.py,sha256=cnyT4Eqrw3lkZjdVkDvN2qMH5yXh68LJhC2w9ccH9Qc,17904
 turboapi/staticfiles.py,sha256=MLSvPeYUQGPEL4_mVQ2z3ItREZxUTEN-awQrNxPAgsM,2861
 turboapi/status.py,sha256=7qVEXVQ3AVFcgEKbmdq6dTypCP275qIbk51hMUQztXA,3049
 turboapi/templating.py,sha256=YlZeesNAuAcqkdUhkE1xGzTY0w_-nhbG5bJWntYe2AM,2087
 turboapi/testclient.py,sha256=TBuRPms8G9MncARfwtvCKvqrtfthraTcy0TkPmweMao,10669
-turboapi/turbonet.cpython-313-darwin.so,sha256=EOg7BGIPvUb8ufbWQw_OjbCVRYth6B1NqAkXeriUAXU,4334200
+turboapi/turbonet.cpython-313-darwin.so,sha256=qaOvLmIwboqv7_subdCl-6q5I38tMZ6VLxRSLo_Ba5Q,5669784
 turboapi/version_check.py,sha256=NmKEt9Qloi5NrGYvVusjFTDhMhZzZfazuXyjcOPO2vc,9357
 turboapi/websockets.py,sha256=7Ao_dKfGWHu2nMU5pm9X20E9P0qnh4lJOykHFmzc5tc,4226
-turboapi-0.4.16.dist-info/METADATA,sha256=QRA-pJvH2qesLSCW-_7YT0ora9YIjuBS5cLfOqq4hiE,12289
-turboapi-0.4.16.dist-info/WHEEL,sha256=y-bBezkr9XqWB_KK0tUa5PfJn4Rf73obH4dbo4t0ZEc,107
-turboapi-0.4.16.dist-info/licenses/LICENSE,sha256=09pmQi_FlhCpUCJ8bMQQoax_oOooJS3FKezznBBU8OQ,1068
-turboapi-0.4.16.dist-info/RECORD,,
+turboapi-0.5.21.dist-info/METADATA,sha256=8q-P0UJmWeRKs9E3YJpaOLNJeZc9OK_elGvCvNjcunM,17556
+turboapi-0.5.21.dist-info/WHEEL,sha256=y-bBezkr9XqWB_KK0tUa5PfJn4Rf73obH4dbo4t0ZEc,107
+turboapi-0.5.21.dist-info/licenses/LICENSE,sha256=09pmQi_FlhCpUCJ8bMQQoax_oOooJS3FKezznBBU8OQ,1068
+turboapi-0.5.21.dist-info/RECORD,,