pyrustapi 0.3.34__tar.gz → 0.3.86__tar.gz

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

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

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

@@ -1,6 +1,6 @@
 [package]
 name = "rustapi"
-version = "0.3.34"
+version = "0.3.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.3.86}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyrustapi
-Version: 0.3.34
+Version: 0.3.86
 Classifier: Development Status :: 3 - Alpha
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3

{pyrustapi-0.3.34 → pyrustapi-0.3.86}/docs/fastapi_compatibility_and_features.md

@@ -168,4 +168,72 @@ def get_item(
     # 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}
+```
+
+---
+
+## 8. FastAPI Migration Mismatch Resolution (v0.3.34)
+
+The following 6 FastAPI compatibility enhancements have been resolved natively in `pyrustapi` v0.3.34:
+
+1. **Sub-Router Nesting (`APIRouter.include_router`)**:
+   `router.include_router(sub_router, prefix="/v1", tags=["sub"])` allows sub-routers to mount additional sub-routers with inherited path prefixes and tags.
+2. **`FastAPI` Constructor Kwargs**:
+   `FastAPI(title="My API", description="...", version="1.0.0", openapi_url="/openapi.json", docs_url="/docs", redoc_url="/redoc")` accepts all standard metadata keyword arguments without constructor errors.
+3. **Custom Exception Handlers (`@app.exception_handler`)**:
+   Register custom status code or exception class handlers via `@app.exception_handler(CustomException)`.
+4. **`HTTPBearer()` Credentials Container**:
+   `security = HTTPBearer()` returns `HTTPAuthorizationCredentials(scheme="Bearer", credentials="...")` when passed to `Depends(security)`.
+5. **Recursive Dependency Injection (`solve_dependency`)**:
+   Injects `request: Request` / `req` parameters automatically and recursively resolves nested `Depends(sub_dep)` calls.
+6. **Dual Async / Sync `UploadFile` Methods**:
+   `UploadFile` methods (`file.read()`, `file.seek()`, `file.close()`) support both asynchronous (`await file.read()`) and synchronous (`file.read()`) execution, plus `.file` returns `io.BytesIO`.
+
 ```

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

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "pyrustapi"
-version = "0.3.34"
+version = "0.3.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.3.86}/python/rustapi/__init__.py

@@ -152,7 +152,7 @@ class RedirectResponse(Response):
         return Response.__new__(cls, content="", status_code=status_code, headers=h)
 
 
-__version__ = "0.3.34"
+__version__ = "0.3.86"
 __all__ = [
     "Engine",
     "FastAPI",

pyrustapi-0.3.86/tests/test_python_ecosystem_compatibility.py

@@ -0,0 +1,114 @@
+import io
+import sqlite3
+import threading
+import time
+import requests
+import jwt
+import httpx
+import numpy as np
+from PIL import Image
+from pydantic import BaseModel, Field
+from rustapi import FastAPI, Request, Depends, HTTPException, status
+from rustapi.uploads import UploadFile
+
+
+# 1. Pydantic Model
+class ImageAnalysisRequest(BaseModel):
+    project_name: str = Field(..., min_length=2)
+    threshold: float = Field(0.5, ge=0.0, le=1.0)
+
+
+# 2. Database Setup (SQLite stdlib)
+def init_db():
+    conn = sqlite3.connect(":memory:", check_same_thread=False)
+    conn.execute("CREATE TABLE users (id INTEGER PRIMARY KEY, username TEXT, token TEXT)")
+    conn.execute("INSERT INTO users (username, token) VALUES ('alice', 'secret_jwt_123')")
+    conn.commit()
+    return conn
+
+db_conn = init_db()
+
+# DB Dependency
+def get_db():
+    return db_conn
+
+
+# 3. Application
+app = FastAPI(title="Ecosystem Compatibility Test App")
+
+
+@app.post("/analyze-image")
+async def analyze_image(req: Request, db=Depends(get_db)):
+    # A. Parse form fields or JSON body with Pydantic
+    try:
+        json_body = await req.json()
+    except Exception:
+        json_body = {}
+
+    project_name = req.form.get("project_name") or json_body.get("project_name") or "default_project"
+    threshold = float(req.form.get("threshold") or json_body.get("threshold") or 0.5)
+    model = ImageAnalysisRequest(project_name=project_name, threshold=threshold)
+
+    # B. Query SQLite database
+    cursor = db.cursor()
+    cursor.execute("SELECT username FROM users WHERE token = 'secret_jwt_123'")
+    row = cursor.fetchone()
+    user = row[0] if row else "unknown"
+
+    # C. Read uploaded file & process image with PIL (Pillow) & NumPy
+    if "photo" not in req.files or not req.files["photo"]:
+        raise HTTPException(status_code=400, detail="No photo uploaded")
+
+    photo_file: UploadFile = req.files["photo"][0]
+    img_bytes = await photo_file.read()
+
+    image = Image.open(io.BytesIO(img_bytes)).convert("L")
+    img_array = np.array(image)
+
+    # Perform NumPy calculation (mean brightness)
+    mean_brightness = float(np.mean(img_array))
+
+    # D. JWT Encoding
+    payload = {"sub": user, "project": model.project_name, "brightness": mean_brightness}
+    encoded_token = jwt.encode(payload, "secret_key_999", algorithm="HS256")
+
+    return {
+        "status": "success",
+        "user": user,
+        "project": model.project_name,
+        "mean_brightness": mean_brightness,
+        "jwt_token": encoded_token,
+    }
+
+
+def test_python_ecosystem_compatibility():
+    port = 8996
+    thread = threading.Thread(target=lambda: app.run(host="127.0.0.1", port=port), daemon=True)
+    thread.start()
+    time.sleep(0.4)
+
+    # Generate sample 100x100 grayscale image in memory using PIL
+    img = Image.new("L", (100, 100), color=128)
+    img_byte_arr = io.BytesIO()
+    img.save(img_byte_arr, format="PNG")
+    png_bytes = img_byte_arr.getvalue()
+
+    # Call endpoint using HTTPX
+    with httpx.Client(base_url=f"http://127.0.0.1:{port}") as client:
+        files = {"photo": ("test_image.png", png_bytes, "image/png")}
+        data = {"project_name": "SkinAnalysis", "threshold": "0.75"}
+
+        response = client.post("/analyze-image", data=data, files=files)
+        assert response.status_code == 200
+
+        res_json = response.json()
+        assert res_json["status"] == "success"
+        assert res_json["user"] == "alice"
+        assert res_json["project"] == "SkinAnalysis"
+        assert res_json["mean_brightness"] == 128.0
+
+        # Decode JWT token to verify PyJWT compatibility
+        decoded = jwt.decode(res_json["jwt_token"], "secret_key_999", algorithms=["HS256"])
+        assert decoded["sub"] == "alice"
+        assert decoded["project"] == "SkinAnalysis"
+        assert decoded["brightness"] == 128.0