turboapi 0.4.15__cp314-cp314t-macosx_11_0_arm64.whl → 0.5.22__cp314-cp314t-macosx_11_0_arm64.whl

turboapi/__init__.py

@@ -1,24 +1,141 @@
 """
 TurboAPI - Revolutionary Python web framework
-Requires Python 3.13+ free-threading for maximum performance
+FastAPI-compatible API with SIMD-accelerated Rust backend.
+Requires Python 3.13+ free-threading for maximum performance.
 """
 
-# Check free-threading compatibility FIRST (before any other imports)
-from .models import TurboRequest, TurboResponse
-from .routing import APIRouter, Router
+# Core application
 from .rust_integration import TurboAPI
-from .version_check import check_free_threading_support
+from .routing import APIRouter, Router
+from .models import TurboRequest, TurboResponse, Request
+
+# Parameter types (FastAPI-compatible)
+from .datastructures import (
+    Body,
+    Cookie,
+    File,
+    Form,
+    Header,
+    Path,
+    Query,
+    UploadFile,
+)
+
+# Response types
+from .responses import (
+    FileResponse,
+    HTMLResponse,
+    JSONResponse,
+    PlainTextResponse,
+    RedirectResponse,
+    Response,
+    StreamingResponse,
+)
+
+# Security
+from .security import (
+    APIKeyCookie,
+    APIKeyHeader,
+    APIKeyQuery,
+    Depends,
+    HTTPBasic,
+    HTTPBasicCredentials,
+    HTTPBearer,
+    HTTPException,
+    OAuth2AuthorizationCodeBearer,
+    OAuth2PasswordBearer,
+    Security,
+    SecurityScopes,
+)
+
+# Exceptions
+from .exceptions import (
+    RequestValidationError,
+    WebSocketException,
+)
+
+# Middleware
+from .middleware import (
+    CORSMiddleware,
+    GZipMiddleware,
+    HTTPSRedirectMiddleware,
+    Middleware,
+    TrustedHostMiddleware,
+)
+
+# Background tasks
+from .background import BackgroundTasks
+
+# WebSocket
+from .websockets import WebSocket, WebSocketDisconnect
+
+# Encoders
+from .encoders import jsonable_encoder
+
+# Status codes module (import as 'status')
+from . import status
+
+# Version check
+from .version_check import check_free_threading_support, get_python_threading_info
 
 __version__ = "2.0.0"
 __all__ = [
+    # Core
     "TurboAPI",
     "APIRouter",
     "Router",
     "TurboRequest",
     "TurboResponse",
+    "Request",
+    # Parameters
+    "Body",
+    "Cookie",
+    "File",
+    "Form",
+    "Header",
+    "Path",
+    "Query",
+    "UploadFile",
+    # Responses
+    "FileResponse",
+    "HTMLResponse",
+    "JSONResponse",
+    "PlainTextResponse",
+    "RedirectResponse",
+    "Response",
+    "StreamingResponse",
+    # Security
+    "APIKeyCookie",
+    "APIKeyHeader",
+    "APIKeyQuery",
+    "Depends",
+    "HTTPBasic",
+    "HTTPBasicCredentials",
+    "HTTPBearer",
+    "HTTPException",
+    "OAuth2AuthorizationCodeBearer",
+    "OAuth2PasswordBearer",
+    "Security",
+    "SecurityScopes",
+    # Exceptions
+    "RequestValidationError",
+    "WebSocketException",
+    # Middleware
+    "CORSMiddleware",
+    "GZipMiddleware",
+    "HTTPSRedirectMiddleware",
+    "Middleware",
+    "TrustedHostMiddleware",
+    # Background tasks
+    "BackgroundTasks",
+    # WebSocket
+    "WebSocket",
+    "WebSocketDisconnect",
+    # Encoders
+    "jsonable_encoder",
+    # Status module
+    "status",
+    # Utils
     "check_free_threading_support",
     "get_python_threading_info",
 ]
-
-# Additional exports for free-threading diagnostics
-from .version_check import get_python_threading_info

turboapi/background.py

@@ -0,0 +1,51 @@
+"""Background tasks support for TurboAPI.
+
+FastAPI-compatible BackgroundTasks class that runs functions after the response is sent.
+"""
+
+import asyncio
+import inspect
+from typing import Any, Callable
+
+
+class BackgroundTasks:
+    """A collection of background tasks to run after the response is sent.
+
+    Usage:
+        @app.post("/send-notification")
+        async def send_notification(background_tasks: BackgroundTasks):
+            background_tasks.add_task(send_email, "user@example.com", message="Hello")
+            return {"message": "Notification sent in the background"}
+    """
+
+    def __init__(self):
+        self._tasks: list[tuple[Callable, tuple, dict]] = []
+
+    @property
+    def tasks(self) -> list[tuple[Callable, tuple, dict]]:
+        """Return the list of tasks (FastAPI compatibility)."""
+        return self._tasks
+
+    def add_task(self, func: Callable, *args: Any, **kwargs: Any) -> None:
+        """Add a task to be run in the background after the response is sent."""
+        self._tasks.append((func, args, kwargs))
+
+    async def __call__(self) -> None:
+        """Execute all background tasks."""
+        for func, args, kwargs in self._tasks:
+            if inspect.iscoroutinefunction(func):
+                await func(*args, **kwargs)
+            else:
+                func(*args, **kwargs)
+
+    def run_tasks(self) -> None:
+        """Run all tasks synchronously or in an event loop."""
+        for func, args, kwargs in self._tasks:
+            if inspect.iscoroutinefunction(func):
+                try:
+                    loop = asyncio.get_running_loop()
+                    loop.create_task(func(*args, **kwargs))
+                except RuntimeError:
+                    asyncio.run(func(*args, **kwargs))
+            else:
+                func(*args, **kwargs)

turboapi/datastructures.py

@@ -0,0 +1,262 @@
+"""Data structures for TurboAPI - Form, File, UploadFile.
+
+FastAPI-compatible parameter markers and file handling classes.
+"""
+
+import io
+import tempfile
+from typing import Any, Optional
+
+
+class Form:
+    """Marker class for form data parameters.
+
+    Usage:
+        @app.post("/login")
+        async def login(username: str = Form(), password: str = Form()):
+            return {"username": username}
+    """
+
+    def __init__(
+        self,
+        default: Any = ...,
+        *,
+        alias: Optional[str] = None,
+        title: Optional[str] = None,
+        description: Optional[str] = None,
+        min_length: Optional[int] = None,
+        max_length: Optional[int] = None,
+        regex: Optional[str] = None,
+        media_type: str = "application/x-www-form-urlencoded",
+    ):
+        self.default = default
+        self.alias = alias
+        self.title = title
+        self.description = description
+        self.min_length = min_length
+        self.max_length = max_length
+        self.regex = regex
+        self.media_type = media_type
+
+
+class File:
+    """Marker class for file upload parameters.
+
+    Usage:
+        @app.post("/upload")
+        async def upload(file: bytes = File()):
+            return {"file_size": len(file)}
+    """
+
+    def __init__(
+        self,
+        default: Any = ...,
+        *,
+        alias: Optional[str] = None,
+        title: Optional[str] = None,
+        description: Optional[str] = None,
+        max_length: Optional[int] = None,
+        media_type: str = "multipart/form-data",
+    ):
+        self.default = default
+        self.alias = alias
+        self.title = title
+        self.description = description
+        self.max_length = max_length
+        self.media_type = media_type
+
+
+class UploadFile:
+    """Represents an uploaded file.
+
+    Usage:
+        @app.post("/upload")
+        async def upload(file: UploadFile):
+            contents = await file.read()
+            return {"filename": file.filename, "size": len(contents)}
+    """
+
+    def __init__(
+        self,
+        filename: Optional[str] = None,
+        file: Optional[io.IOBase] = None,
+        content_type: str = "application/octet-stream",
+        *,
+        size: Optional[int] = None,
+        headers: Optional[dict] = None,
+    ):
+        self.filename = filename
+        self.content_type = content_type
+        self.size = size
+        self.headers = headers or {}
+        if file is None:
+            self.file = tempfile.SpooledTemporaryFile(max_size=1024 * 1024)
+        else:
+            self.file = file
+
+    async def read(self, size: int = -1) -> bytes:
+        """Read file contents."""
+        if hasattr(self.file, "read"):
+            return self.file.read(size)
+        return b""
+
+    async def write(self, data: bytes) -> None:
+        """Write data to the file."""
+        if hasattr(self.file, "write"):
+            self.file.write(data)
+
+    async def seek(self, offset: int) -> None:
+        """Seek to a position in the file."""
+        if hasattr(self.file, "seek"):
+            self.file.seek(offset)
+
+    async def close(self) -> None:
+        """Close the file."""
+        if hasattr(self.file, "close"):
+            self.file.close()
+
+    def __repr__(self) -> str:
+        return f"UploadFile(filename={self.filename!r}, content_type={self.content_type!r}, size={self.size})"
+
+
+class Header:
+    """Marker class for header parameters.
+
+    Usage:
+        @app.get("/items")
+        async def read_items(x_token: str = Header()):
+            return {"X-Token": x_token}
+    """
+
+    def __init__(
+        self,
+        default: Any = ...,
+        *,
+        alias: Optional[str] = None,
+        title: Optional[str] = None,
+        description: Optional[str] = None,
+        convert_underscores: bool = True,
+    ):
+        self.default = default
+        self.alias = alias
+        self.title = title
+        self.description = description
+        self.convert_underscores = convert_underscores
+
+
+class Cookie:
+    """Marker class for cookie parameters.
+
+    Usage:
+        @app.get("/items")
+        async def read_items(session_id: str = Cookie()):
+            return {"session_id": session_id}
+    """
+
+    def __init__(
+        self,
+        default: Any = ...,
+        *,
+        alias: Optional[str] = None,
+        title: Optional[str] = None,
+        description: Optional[str] = None,
+    ):
+        self.default = default
+        self.alias = alias
+        self.title = title
+        self.description = description
+
+
+class Query:
+    """Marker class for query parameters with validation.
+
+    Usage:
+        @app.get("/items")
+        async def read_items(q: str = Query(min_length=3)):
+            return {"q": q}
+    """
+
+    def __init__(
+        self,
+        default: Any = ...,
+        *,
+        alias: Optional[str] = None,
+        title: Optional[str] = None,
+        description: Optional[str] = None,
+        min_length: Optional[int] = None,
+        max_length: Optional[int] = None,
+        regex: Optional[str] = None,
+        gt: Optional[float] = None,
+        ge: Optional[float] = None,
+        lt: Optional[float] = None,
+        le: Optional[float] = None,
+    ):
+        self.default = default
+        self.alias = alias
+        self.title = title
+        self.description = description
+        self.min_length = min_length
+        self.max_length = max_length
+        self.regex = regex
+        self.gt = gt
+        self.ge = ge
+        self.lt = lt
+        self.le = le
+
+
+class Path:
+    """Marker class for path parameters with validation.
+
+    Usage:
+        @app.get("/items/{item_id}")
+        async def read_item(item_id: int = Path(gt=0)):
+            return {"item_id": item_id}
+    """
+
+    def __init__(
+        self,
+        default: Any = ...,
+        *,
+        alias: Optional[str] = None,
+        title: Optional[str] = None,
+        description: Optional[str] = None,
+        gt: Optional[float] = None,
+        ge: Optional[float] = None,
+        lt: Optional[float] = None,
+        le: Optional[float] = None,
+    ):
+        self.default = default
+        self.alias = alias
+        self.title = title
+        self.description = description
+        self.gt = gt
+        self.ge = ge
+        self.lt = lt
+        self.le = le
+
+
+class Body:
+    """Marker class for body parameters.
+
+    Usage:
+        @app.post("/items")
+        async def create_item(name: str = Body(), price: float = Body()):
+            return {"name": name, "price": price}
+    """
+
+    def __init__(
+        self,
+        default: Any = ...,
+        *,
+        embed: bool = False,
+        alias: Optional[str] = None,
+        title: Optional[str] = None,
+        description: Optional[str] = None,
+        media_type: str = "application/json",
+    ):
+        self.default = default
+        self.embed = embed
+        self.alias = alias
+        self.title = title
+        self.description = description
+        self.media_type = media_type