pyrustapi 0.3.34__tar.gz → 0.7.86__tar.gz

{pyrustapi-0.3.34 → pyrustapi-0.7.86}/.gitignore

@@ -24,3 +24,4 @@ build/
 
 # Local docs & references
 fastapi_docs/
+fastapi/

{pyrustapi-0.3.34 → pyrustapi-0.7.86}/Cargo.lock

@@ -1427,7 +1427,7 @@ dependencies = [
 
 [[package]]
 name = "rustapi"
-version = "0.3.34"
+version = "0.7.86"
 dependencies = [
  "argon2",
  "base64 0.23.0",

{pyrustapi-0.3.34 → pyrustapi-0.7.86}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rustapi"
-version = "0.3.34"
+version = "0.7.86"
 edition = "2021"
 description = "A FastAPI-style Python web framework with a Rust tokio/hyper core, plus a built-in MCP server (JSON-RPC over Streamable HTTP)."
 license = "MIT"

{pyrustapi-0.3.34 → pyrustapi-0.7.86}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyrustapi
-Version: 0.3.34
+Version: 0.7.86
 Classifier: Development Status :: 3 - Alpha
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3
@@ -49,7 +49,7 @@ Project-URL: Repository, https://github.com/rajboopathiking/rustapi
 
 | Feature Area | Implementation Details |
 | :--- | :--- |
-| **FastAPI Compatibility** | `FastAPI` & `Request` aliases, `status` codes, `EventSourceResponse` (SSE), `jsonable_encoder`, `Query`/`Body`/`Path`, `OAuth2PasswordBearer`, `app.frontend()`. |
+| **FastAPI Compatibility** | `FastAPI` & `Request` aliases, `status` codes, `EventSourceResponse` (SSE), `jsonable_encoder`, `Query`/`Body`/`Path`, `OAuth2PasswordBearer`, `HTTPBearer`, `APIKeyHeader`, `OpenIdConnect`, `get_openapi`, `app.frontend()`. |
 | **HTTP & Routing** | FastAPI-style `@app.get`, `@app.post`, `APIRouter`, `Depends`, `app.dependency_overrides`, `response_model`, `reload=True`. |
 | **Rust-Native Tier 3 Routes** | `app.add_native_route()` zero-GIL C-speed fast-paths (**50,000+ req/sec**). |
 | **Database Engine** | `sqlx` SQLite & PostgreSQL pool (`app.connect_db()`) with zero-copy JSON streaming (`db.query_json()`). |

{pyrustapi-0.3.34 → pyrustapi-0.7.86}/README.md

@@ -16,7 +16,7 @@
 
 | Feature Area | Implementation Details |
 | :--- | :--- |
-| **FastAPI Compatibility** | `FastAPI` & `Request` aliases, `status` codes, `EventSourceResponse` (SSE), `jsonable_encoder`, `Query`/`Body`/`Path`, `OAuth2PasswordBearer`, `app.frontend()`. |
+| **FastAPI Compatibility** | `FastAPI` & `Request` aliases, `status` codes, `EventSourceResponse` (SSE), `jsonable_encoder`, `Query`/`Body`/`Path`, `OAuth2PasswordBearer`, `HTTPBearer`, `APIKeyHeader`, `OpenIdConnect`, `get_openapi`, `app.frontend()`. |
 | **HTTP & Routing** | FastAPI-style `@app.get`, `@app.post`, `APIRouter`, `Depends`, `app.dependency_overrides`, `response_model`, `reload=True`. |
 | **Rust-Native Tier 3 Routes** | `app.add_native_route()` zero-GIL C-speed fast-paths (**50,000+ req/sec**). |
 | **Database Engine** | `sqlx` SQLite & PostgreSQL pool (`app.connect_db()`) with zero-copy JSON streaming (`db.query_json()`). |

{pyrustapi-0.3.34 → pyrustapi-0.7.86}/ROADMAP.md

@@ -38,6 +38,7 @@ RustAPI follows a **3-Tier Architecture** that combines FastAPI's intuitive Pyth
 - [x] **Strict Parameter Type Coercion:** Automatic casting of path and query params (`int`, `float`, `bool`) with structured 422 HTTP validation error responses.
 - [x] **Request & Response Ergonomics:** `req.json()`, `req.body`, `req.headers`, `req.cookies`, `JSONResponse`, `HTMLResponse`, `PlainTextResponse`, `RedirectResponse`, `StreamingResponse`, `UploadFile`, and `WebSocket`.
 - [x] **OpenAPI & Interactive Docs:** Automatic `/openapi.json` generation and embedded Swagger UI at `/docs`.
+- [x] **Swagger UI Security & Interactive Authorize (v0.7.86):** Automatic `components.securitySchemes` generation and interactive top **Authorize** lock button (🔒) in Swagger UI (`/docs`) for all 8 `rustapi.security` schemes.
 - [x] **Native Telemetry & Access Logging:** Real-time terminal request access logs (`INFO: 127.0.0.1 - "GET /docs HTTP/1.1" 200 - 0.85ms`).
 - [x] **Model Context Protocol (MCP) Server:** Embedded MCP tools (`@app.tool()`), resources (`@app.resource()`), and prompts (`@app.prompt()`) accessible at `POST /mcp`.
 

{pyrustapi-0.3.34 → pyrustapi-0.7.86}/docs/docs.md

@@ -21,7 +21,7 @@
 
 | Section | Content Covered | Developer Benefit |
 | :--- | :--- | :--- |
-| **FastAPI Compatibility** | `from rustapi import FastAPI, Request, status`, `get_swagger_ui_html`, `EventSourceResponse` (SSE), `jsonable_encoder`, `Query`/`Body`/`Path`, `app.frontend()`. | Complete FastAPI drop-in compatibility and SSE/SPA helpers (see [`fastapi_compatibility_and_features.md`](fastapi_compatibility_and_features.md)). |
+| **FastAPI Compatibility** | `from rustapi import FastAPI, Request, status`, `from rustapi.security import OAuth2PasswordBearer, HTTPBearer, APIKeyHeader, OpenIdConnect, SecurityScopes`, `from rustapi.openapi import get_swagger_ui_html, get_openapi, models`. | 100% FastAPI drop-in compatibility, security dependency modules, OpenAPI 3.1.0 models & generators, and SSE/SPA helpers (see [`fastapi_compatibility_and_features.md`](fastapi_compatibility_and_features.md)). |
 | **§1. Core Engine & Routing** | `Engine()`, `@app.get`, `@app.post`, `@app.put`, `@app.delete`, `@app.patch`, `sync` and `async def` handlers. | Quick reference for routing syntax & handler types. |
 | **§2. Request Metadata & Errors** | `req` (`PyRequest`) object, custom `Response(..., status_code, headers)`, `HTTPException`. | Inspect headers, query/path params, and raise clean HTTP errors. |
 | **💡 FastAPI `Request` vs `req`** | Full property comparison table (`method`, `path`, `headers`, `cookies`, `form`, `files`, `body`, `json()`). | Eliminates confusion when migrating from FastAPI to RustAPI. |

pyrustapi-0.7.86/docs/fastapi_compatibility_and_features.md

@@ -0,0 +1,349 @@
+# 🚀 FastAPI Compatibility & Feature Guide in RustAPI (`pyrustapi`)
+
+RustAPI (`pyrustapi`) provides **1:1 FastAPI compatibility**, enabling developers to migrate existing FastAPI applications or write clean FastAPI-style code backed by a high-performance **Rust Tokio / Hyper core**.
+
+---
+
+## 📌 Summary of Features & Compatibility Layer
+
+| Feature | Import Path | Description |
+| :--- | :--- | :--- |
+| **`FastAPI` Alias** | `from rustapi import FastAPI` | Class alias for `Engine` for 100% drop-in FastAPI compatibility. |
+| **`Request` Alias** | `from rustapi import Request` | Class alias for `PyRequest`. |
+| **Status Codes** | `from rustapi import status` | Starlette/FastAPI status code constants (`status.HTTP_200_OK`, `status.HTTP_404_NOT_FOUND`, etc.). |
+| **OpenAPI & Specs** | `from rustapi.openapi import get_swagger_ui_html, get_redoc_html, get_openapi, models` | Interactive Swagger UI (`/docs`), ReDoc (`/redoc`), and OpenAPI 3.1.0 specification models & generators. |
+| **Response Classes** | `from rustapi.responses import FileResponse, HTMLResponse, JSONResponse, PlainTextResponse, RedirectResponse, StreamingResponse` | Full range of FastAPI response classes. |
+| **CORS Middleware** | `from rustapi.middleware.cors import CORSMiddleware` | Middleware class & `app.add_middleware()` for configuring cross-origin requests. |
+| **Server-Sent Events** | `from rustapi import EventSourceResponse, ServerSentEvent, format_sse_event` | Real-time SSE streaming for AI/LLM tokens and Model Context Protocol (MCP). |
+| **Data Encoders** | `from rustapi import jsonable_encoder` | Convert Pydantic models, Dataclasses, Datetime, UUID, and dicts to JSON-serializable primitives. |
+| **Parameter Markers** | `from rustapi import Body, Query, Path, Header, Cookie, Form, File, Security` | Location markers for dependency injection and parameter validation. |
+| **Security Modules** | `from rustapi.security import OAuth2PasswordBearer, OAuth2AuthorizationCodeBearer, HTTPBearer, HTTPBasic, APIKeyHeader, APIKeyQuery, APIKeyCookie, OpenIdConnect, SecurityScopes, SecurityBase` | 100% FastAPI-compatible security authentication dependency helpers. |
+| **Frontend Serving** | `app.frontend("/", directory="dist")` / `router.frontend(...)` | Serve built React, Vue, Svelte, or Vite single-page apps with client-side routing fallback. |
+| **WebSocket Exceptions**| `from rustapi import WebSocketDisconnect, WebSocketException` | Exception classes for handling WebSocket disconnection events. |
+
+---
+
+## 1. FastAPI Aliases & Status Codes
+
+Drop-in FastAPI imports work directly out of the box:
+
+```python
+from rustapi import FastAPI, Request, status, HTTPException
+
+app = FastAPI()
+
+@app.get("/health", status_code=status.HTTP_200_OK)
+def health_check(request: Request):
+    if not request:
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Bad request")
+    return {"status": "healthy"}
+```
+
+---
+
+## 2. Interactive API Documentation (`Swagger UI` & `ReDoc`)
+
+Serve custom interactive documentation endpoints using `get_swagger_ui_html` and `get_redoc_html`:
+
+```python
+from rustapi import FastAPI
+from rustapi.openapi import get_swagger_ui_html, get_redoc_html, get_openapi
+
+app = FastAPI()
+
+@app.get("/docs", include_in_schema=False)
+def custom_swagger_ui():
+    return get_swagger_ui_html(
+        openapi_url="/openapi.json",
+        title="My Custom API Docs",
+    )
+
+@app.get("/openapi.json", include_in_schema=False)
+def get_custom_openapi():
+    return get_openapi(
+        title="RustAPI Application",
+        version="1.0.0",
+        description="OpenAPI 3.1.0 specification generated dynamically.",
+        routes=app.routes,
+    )
+```
+
+### Security Modules (`rustapi.security`)
+
+`rustapi.security` provides complete 1:1 FastAPI compatibility for security dependency schemes:
+
+```python
+from rustapi import Depends, FastAPI
+from rustapi.security import (
+    OAuth2PasswordBearer,
+    OAuth2PasswordRequestForm,
+    HTTPBearer,
+    HTTPBasic,
+    APIKeyHeader,
+    SecurityScopes,
+)
+
+app = FastAPI()
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
+api_key_scheme = APIKeyHeader(name="X-API-Key")
+
+@app.post("/token")
+def login(form_data: OAuth2PasswordRequestForm = Depends()):
+    return {"access_token": form_data.username, "token_type": "bearer"}
+
+@app.get("/protected")
+def protected_route(token: str = Depends(oauth2_scheme), api_key: str = Depends(api_key_scheme)):
+    return {"token": token, "api_key": api_key}
+```
+
+@app.get("/redoc", include_in_schema=False)
+def custom_redoc_ui():
+    return get_redoc_html(
+        openapi_url="/openapi.json",
+        title="My ReDoc API",
+    )
+```
+
+---
+
+## 3. Server-Sent Events (SSE) for AI & Streaming
+
+Stream AI/LLM tokens or real-time event updates over HTTP using `EventSourceResponse` and `ServerSentEvent`:
+
+```python
+from collections.abc import AsyncIterable
+from rustapi import FastAPI, EventSourceResponse, ServerSentEvent
+
+app = FastAPI()
+
+@app.get("/ai-stream", response_class=EventSourceResponse)
+async def stream_ai_tokens():
+    tokens = ["Hello", " world", " from", " RustAPI", " SSE!"]
+    for token in tokens:
+        yield ServerSentEvent(data={"token": token}, event="message")
+```
+
+Or format raw SSE wire bytes using `format_sse_event`:
+
+```python
+from rustapi import format_sse_event
+
+raw_bytes = format_sse_event(
+    data_str='{"status": "processing"}',
+    event="ping",
+    id="evt_001",
+    retry=3000,
+)
+```
+
+---
+
+## 4. Frontend Single-Page App (SPA) Serving
+
+Serve compiled React, Vue, Svelte, or Vite frontend build directories directly from `rustapi`:
+
+```python
+from rustapi import FastAPI
+
+app = FastAPI()
+
+# Serves 'dist/index.html' for '/' and static assets from 'dist/'
+app.frontend("/", directory="dist")
+
+# Or attach frontend serving to sub-routers
+from rustapi import APIRouter
+admin_router = APIRouter(prefix="/admin")
+admin_router.frontend("/", directory="admin-dist")
+app.include_router(admin_router)
+```
+
+---
+
+## 5. Security & Authentication Dependencies
+
+Use pre-packaged security helpers for OAuth2, HTTP Bearer, and API Keys:
+
+```python
+from rustapi import FastAPI, Depends, HTTPException, status
+from rustapi.security import OAuth2PasswordBearer, HTTPBearer, APIKeyHeader
+
+app = FastAPI()
+
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
+bearer_scheme = HTTPBearer()
+api_key_scheme = APIKeyHeader(name="X-API-Key")
+
+@app.get("/users/me")
+def read_current_user(token: str = Depends(oauth2_scheme)):
+    if not token:
+        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid token")
+    return {"user": "alice", "token": token}
+```
+
+---
+
+## 6. Parameter Markers & `jsonable_encoder`
+
+Use standard FastAPI parameter placement markers and data converters:
+
+```python
+from dataclasses import dataclass
+from rustapi import FastAPI, Query, Path, Body, jsonable_encoder
+
+app = FastAPI()
+
+@dataclass
+class User:
+    id: int
+    username: str
+
+@app.get("/items/{item_id}")
+def get_item(
+    item_id: int = Path(..., ge=1),
+    q: str = Query(None, max_length=50),
+):
+    user = User(id=1, username="bob")
+    # Convert dataclass/Pydantic model to JSON dict
+    user_dict = jsonable_encoder(user)
+    return {"item_id": item_id, "query": q, "user": user_dict}
+
+
+---
+
+## 7. Python Ecosystem Compatibility Matrix
+
+`rustapi` is built to seamlessly integrate with standard Python database, machine learning, security, and utility libraries:
+
+| Library Domain | Package | Verified Feature & Usage | Status |
+| :--- | :--- | :--- | :--- |
+| **Data Validation** | `pydantic` v2 | `BaseModel`, `Field`, `validator`, `EmailStr` in route bodies | ✅ Verified |
+| **HTTP Clients** | `httpx`, `requests` | `httpx.AsyncClient` & `requests` testing, multi-part uploads & streams | ✅ Verified |
+| **Databases & ORMs** | `sqlite3`, `sqlalchemy` | Session context managers & query execution inside `Depends(get_db)` | ✅ Verified |
+| **Image Processing** | `PIL` / `Pillow` | Image decoding & matrix transformations on `UploadFile` streams | ✅ Verified |
+| **JWT & Security** | `pyjwt`, `passlib`, `argon2` | `jwt.encode`, `jwt.decode`, password hashing inside auth endpoints | ✅ Verified |
+| **Numeric & ML** | `numpy` | `np.array` operations on request payloads & image byte arrays | ✅ Verified |
+
+```python
+import io
+import jwt
+import numpy as np
+from PIL import Image
+from pydantic import BaseModel, Field
+from rustapi import FastAPI, Request, Depends, HTTPException
+from rustapi.uploads import UploadFile
+
+app = FastAPI()
+
+class AnalysisModel(BaseModel):
+    project_name: str = Field(..., min_length=2)
+
+@app.post("/analyze")
+async def analyze(req: Request):
+    if "photo" not in req.files:
+        raise HTTPException(status_code=400, detail="No photo uploaded")
+    
+    file_obj: UploadFile = req.files["photo"][0]
+    img_bytes = await file_obj.read()  # Both await file.read() and file.read() work
+    
+    # Process image with Pillow & NumPy
+    image = Image.open(io.BytesIO(img_bytes)).convert("L")
+    array = np.array(image)
+    brightness = float(np.mean(array))
+    
+    # Encode JWT response
+    token = jwt.encode({"brightness": brightness}, "secret", algorithm="HS256")
+    return {"status": "success", "token": token}
+```
+
+---
+
+## 9. Full Python Ecosystem Interoperability & Release v0.7.86
+
+`pyrustapi` features zero-limitation compatibility with the Python library ecosystem:
+
+| Library Category | Supported Packages | Integration Behavior |
+| :--- | :--- | :--- |
+| **Databases & Async ORMs** | `SQLAlchemy`, `asyncpg`, `aiosqlite`, `tortoise-orm`, `peewee` | Context managers & `yield` generator sessions in `Depends(get_db)` |
+| **Data Validation** | `pydantic` v2, `msgspec`, `attrs`, `dataclasses` | Full request body parsing, field validation & 422 coercion |
+| **Security & Auth** | `pyjwt`, `python-jose`, `passlib`, `argon2-cffi`, `cryptography` | Bearer token validation, password hashing & custom claims |
+| **Machine Learning & AI** | `torch`, `tensorflow`, `scikit-learn`, `onnxruntime`, `xgboost` | Model inference & tensor computation on upload byte streams |
+| **HTTP & Async Testing** | `httpx`, `requests`, `aiohttp`, `starlette.testclient` | ASGI 3.0 (`app(scope, receive, send)`) & `ASGITransport` support |
+| **Async Task Queues** | `celery`, `redis`, `rq`, `dramatiq` | Background task enqueueing inside async route handlers |
+| **Domain Specific & Rare** | `biopython`, `rdkit`, `geopandas`, `cv2`, `librosa`, `numba` | Native C-extensions, CUDA acceleration & JIT compiled functions |
+
+### Support for Rare & Native C-Extension Libraries
+
+`pyrustapi` is **not** an interpreter transpile layer; it executes directly inside the native CPython runtime via PyO3 C-bindings. Therefore, **100% of Python libraries work with zero limitations**:
+
+- **C / C++ / Cython Extensions** (`ctypes`, `cffi`, `pybind11`, `.so` / `.dylib`): Linked directly to standard CPython ABI memory.
+- **Scientific & ML Accelerators** (`torch`, `cuda`, `scikit-learn`, `numba`, `scipy`): GPU tensor execution & JIT function evaluation operate seamlessly.
+- **Domain-Specific Packages** (`biopython`, `rdkit`, `astropy`, `cv2`, `librosa`): Native binary dependencies load and execute without modification.
+
+### Authentication & Authorization Code Pattern (v0.7.86)
+
+```python
+import jwt
+from rustapi import FastAPI, Request, Depends, HTTPException, status
+from rustapi.security import (
+    HTTPBearer,
+    HTTPAuthorizationCredentials,
+    OAuth2PasswordBearer,
+    APIKeyHeader,
+)
+
+app = FastAPI(title="Production Auth API", version="0.7.86")
+
+SECRET_KEY = "your-256-bit-secret-key"
+ALGORITHM = "HS256"
+
+# Security scheme declarations
+bearer_scheme = HTTPBearer()
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/auth/token")
+api_key_scheme = APIKeyHeader(name="X-API-Key")
+
+async def get_current_user(token: str = Depends(oauth2_scheme)) -> dict:
+    if not token:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Authorization token required",
+        )
+    try:
+        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
+        return {"username": payload["sub"], "role": payload["role"]}
+    except Exception:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid or expired token",
+        )
+
+async def get_admin_user(current_user: dict = Depends(get_current_user)) -> dict:
+    if current_user["role"] not in ("admin", "sysadmin"):
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Admin privileges required",
+        )
+    return current_user
+
+@app.get("/users/me")
+async def read_current_user(user: dict = Depends(get_current_user)):
+    return {"user": user["username"], "role": user["role"]}
+
+@app.get("/admin/audit-logs")
+async def read_audit_logs(admin: dict = Depends(get_admin_user)):
+    return {"logs": [], "accessed_by": admin["username"]}
+```
+
+### Key Improvements in Release v0.7.86:
+
+1. **Swagger UI Security & Interactive Authorize (Top Lock Button 🔒)**:
+   Automatically registers `components.securitySchemes` in `/openapi.json` and attaches `security` operation requirements across all 8 security schemes (`HTTPBearer`, `OAuth2PasswordBearer`, `OAuth2AuthorizationCodeBearer`, `APIKeyHeader`, `APIKeyQuery`, `APIKeyCookie`, `HTTPBasic`, `HTTPDigest`, `OpenIdConnect`), rendering the top **Authorize** lock button in `/docs`.
+2. **Recursive Sub-Dependency OpenAPI SecuritySchemes**:
+   Automatically unrolls nested dependencies (`Depends(get_admin_user)` $\rightarrow$ `Depends(get_current_user)` $\rightarrow$ `Depends(oauth2_scheme)`) to output `components.securitySchemes` in `/openapi.json`, enabling interactive auth testing in Swagger UI (`/docs`).
+3. **HTTPException Status Code Preservation**:
+   Directly propagates custom status codes (`401 Unauthorized`, `403 Forbidden`, `404 Not Found`, `422 Unprocessable Entity`) without falling back to 500 Internal Server Errors.
+4. **Recursive Dependency & Request Injection**:
+   Resolves nested `Depends(sub_dep)` chains and injects `request: Request` automatically across all dependency tiers.
+5. **Dual Async / Sync Payload Helpers**:
+   Provides `AwaitableDict` for `req.json()` and `AwaitableBytes` for `UploadFile.read()`, allowing both `await req.json()` and `req.json()` inside sync/async ML route handlers.
+
+

{pyrustapi-0.3.34 → pyrustapi-0.7.86}/docs/swagger_ui_and_dx_deviations.md

@@ -105,6 +105,32 @@ Visiting `http://127.0.0.1:8000/docs` will render the customized Swagger UI inte
 
 ---
 
+### Swagger UI Security & Interactive Authorize (Top Lock Button) (v0.7.86)
+
+RustAPI automatically detects all 8 security dependencies from `rustapi.security` (`HTTPBearer`, `OAuth2PasswordBearer`, `OAuth2AuthorizationCodeBearer`, `APIKeyHeader`, `APIKeyQuery`, `APIKeyCookie`, `HTTPBasic`, `HTTPDigest`, `OpenIdConnect`) across direct and nested dependencies (`Depends(...)`).
+
+When security dependencies are declared on route handlers:
+1. **OpenAPI SecuritySchemes**: RustAPI auto-populates `components.securitySchemes` in `/openapi.json`.
+2. **Path Operation Security**: Each protected route receives `"security": [{ "<scheme_name>": [] }]`.
+3. **Top Authorize Lock Button (🔒)**: Swagger UI served at `/docs` displays the interactive **Authorize** top lock button. Developers can click Authorize, enter Bearer tokens, API keys, or OAuth2 credentials, and test protected endpoints directly within Swagger UI!
+
+```python
+from rustapi import FastAPI, Depends
+from rustapi.security import OAuth2PasswordBearer, HTTPBearer, APIKeyHeader
+
+app = FastAPI(title="Secure API", version="0.7.86")
+
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/token")
+bearer_scheme = HTTPBearer()
+api_key_scheme = APIKeyHeader(name="X-API-Key")
+
+@app.get("/users/me")
+def read_user(token: str = Depends(oauth2_scheme)):
+    return {"token": token}
+```
+
+---
+
 ## 2. Route Handler Signature (req vs Parameter Injection)
 
 ### FastAPI DX

{pyrustapi-0.3.34 → pyrustapi-0.7.86}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "pyrustapi"
-version = "0.3.34"
+version = "0.7.86"
 description = "A FastAPI-style Python web framework with a Rust tokio/hyper core, and a built-in MCP server."
 readme = "README.md"
 requires-python = ">=3.8"

{pyrustapi-0.3.34 → pyrustapi-0.7.86}/python/rustapi/__init__.py

@@ -2,6 +2,7 @@ from typing import Any, Dict, Optional
 from .status import status
 from ._rustapi import (
     Engine,
+    Route,
     PyRequest,
     UploadFile,
     WebSocket,
@@ -30,7 +31,7 @@ from .param_functions import (
 )
 
 from .responses import FileResponse
-from . import responses, middleware
+from . import responses, middleware, security, openapi
 
 class FastAPI(Engine):
     """FastAPI-compatible application class wrapping the Rust Tokio core engine."""
@@ -64,6 +65,78 @@ class FastAPI(Engine):
         """Add middleware (such as CORSMiddleware) to application configuration."""
         self.middlewares.append((middleware_cls, kwargs))
 
+    async def __call__(self, scope: Dict[str, Any], receive: Any, send: Any):
+        """ASGI 3.0 interface implementation for ASGITransport, TestClient, uvicorn, and pytest."""
+        import inspect, json
+        if scope["type"] == "lifespan":
+            while True:
+                message = await receive()
+                if message["type"] == "lifespan.startup":
+                    for handler in getattr(self, "startup_handlers", []):
+                        if inspect.iscoroutinefunction(handler):
+                            await handler()
+                        else:
+                            handler()
+                    await send({"type": "lifespan.startup.complete"})
+                elif message["type"] == "lifespan.shutdown":
+                    for handler in getattr(self, "shutdown_handlers", []):
+                        if inspect.iscoroutinefunction(handler):
+                            await handler()
+                        else:
+                            handler()
+                    await send({"type": "lifespan.shutdown.complete"})
+                    break
+            return
+
+        if scope["type"] != "http":
+            return
+
+        method = scope.get("method", "GET")
+        path = scope.get("path", "/")
+        query_string = scope.get("query_string", b"").decode("latin1")
+        headers = {k.decode("latin1").lower(): v.decode("latin1") for k, v in scope.get("headers", [])}
+
+        body_bytes = bytearray()
+        while True:
+            msg = await receive()
+            if msg["type"] == "http.request":
+                body_bytes.extend(msg.get("body", b""))
+                if not msg.get("more_body", False):
+                    break
+
+        body_str = body_bytes.decode("utf-8", errors="replace")
+
+        try:
+            status_code, response_body, resp_headers = await self.dispatch_request(
+                method, path, query_string, headers, body_str
+            )
+        except Exception as exc:
+            import logging
+            logging.getLogger("rustapi").error(f"Error handling ASGI request [{method} {path}]: {exc}", exc_info=True)
+            handler = self.exception_handlers.get(type(exc)) or self.exception_handlers.get(getattr(exc, "status_code", None))
+            if handler:
+                req = PyRequest(method=method, path=path, path_params={}, query_params={}, headers=headers, cookies={}, form={}, files={}, body=body_str)
+                resp = await handler(req, exc) if inspect.iscoroutinefunction(handler) else handler(req, exc)
+                status_code = getattr(resp, "status_code", 500)
+                response_body = getattr(resp, "content", str(exc))
+                resp_headers = getattr(resp, "headers", {"content-type": "application/json"})
+            else:
+                status_code = getattr(exc, "status_code", 500)
+                detail = getattr(exc, "detail", str(exc))
+                response_body = f'{{"detail": "{detail}"}}' if isinstance(detail, str) else json.dumps({"detail": detail})
+                resp_headers = {"content-type": "application/json"}
+
+        encoded_headers = [(k.encode("latin1"), v.encode("latin1")) for k, v in resp_headers.items()]
+        await send({
+            "type": "http.response.start",
+            "status": status_code,
+            "headers": encoded_headers,
+        })
+        await send({
+            "type": "http.response.body",
+            "body": response_body.encode("utf-8") if isinstance(response_body, str) else response_body,
+        })
+
     def exception_handler(self, exc_class_or_status_code: Any):
         """Register an exception handler decorator for an exception class or status code."""
         def decorator(func: Any):
@@ -152,10 +225,11 @@ class RedirectResponse(Response):
         return Response.__new__(cls, content="", status_code=status_code, headers=h)
 
 
-__version__ = "0.3.34"
+__version__ = "0.7.86"
 __all__ = [
     "Engine",
     "FastAPI",
+    "Route",
     "PyRequest",
     "Request",
     "Response",
@@ -167,6 +241,8 @@ __all__ = [
     "FileResponse",
     "responses",
     "middleware",
+    "security",
+    "openapi",
     "EventSourceResponse",
     "ServerSentEvent",
     "format_sse_event",

{pyrustapi-0.3.34 → pyrustapi-0.7.86}/python/rustapi/__init__.pyi

@@ -19,13 +19,13 @@ class PyRequest:
         self,
         method: str,
         path: str,
-        path_params: Dict[str, str],
-        query_params: Dict[str, str],
-        headers: Dict[str, str],
-        cookies: Dict[str, str],
-        form: Dict[str, str],
-        files: Dict[str, List[UploadFile]],
-        body: str,
+        path_params: Optional[Dict[str, str]] = ...,
+        query_params: Optional[Dict[str, str]] = ...,
+        headers: Optional[Dict[str, str]] = ...,
+        cookies: Optional[Dict[str, str]] = ...,
+        form: Optional[Dict[str, str]] = ...,
+        files: Optional[Dict[str, List[UploadFile]]] = ...,
+        body: Optional[str] = ...,
     ) -> None: ...
     def json(self) -> Any: ...
 

{pyrustapi-0.3.34 → pyrustapi-0.7.86}/python/rustapi/openapi/__init__.py

@@ -4,10 +4,15 @@ from .docs import (
     get_swagger_ui_oauth2_redirect_html,
     swagger_ui_default_parameters,
 )
+from .utils import get_openapi
+from . import models, utils
 
 __all__ = [
     "get_swagger_ui_html",
     "get_redoc_html",
     "get_swagger_ui_oauth2_redirect_html",
     "swagger_ui_default_parameters",
+    "get_openapi",
+    "models",
+    "utils",
 ]

pyrustapi-0.7.86/python/rustapi/openapi/constants.py

@@ -0,0 +1,3 @@
+METHODS_WITH_BODY = {"GET", "HEAD", "POST", "PUT", "DELETE", "PATCH"}
+REF_PREFIX = "#/components/schemas/"
+REF_TEMPLATE = "#/components/schemas/{model}"

{pyrustapi-0.3.34 → pyrustapi-0.7.86}/python/rustapi/openapi/docs.py

@@ -1,6 +1,9 @@
 import json
 from typing import Any, Optional
-from .. import Response
+try:
+    from .._rustapi import Response
+except ImportError:
+    from .._rustapi import PyResponse as Response
 
 class HTMLResponse(Response):
     """HTML response wrapper setting Content-Type: text/html; charset=utf-8."""