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

turboapi/encoders.py

@@ -0,0 +1,323 @@
+"""
+JSON encoding utilities (FastAPI-compatible).
+
+This module provides the jsonable_encoder function for converting
+objects to JSON-serializable dictionaries.
+"""
+
+import dataclasses
+from collections import deque
+from datetime import date, datetime, time, timedelta
+from decimal import Decimal
+from enum import Enum
+from pathlib import Path, PurePath
+from typing import Any, Callable, Dict, List, Optional, Set, Tuple, Type, Union
+from uuid import UUID
+
+# Try to import dhi BaseModel
+try:
+    from dhi import BaseModel
+
+    HAS_DHI = True
+except ImportError:
+    BaseModel = None
+    HAS_DHI = False
+
+# Try to import Pydantic for compatibility
+try:
+    import pydantic
+
+    HAS_PYDANTIC = True
+except ImportError:
+    HAS_PYDANTIC = False
+
+
+ENCODERS_BY_TYPE: Dict[Type[Any], Callable[[Any], Any]] = {
+    bytes: lambda o: o.decode(),
+    date: lambda o: o.isoformat(),
+    datetime: lambda o: o.isoformat(),
+    time: lambda o: o.isoformat(),
+    timedelta: lambda o: o.total_seconds(),
+    Decimal: float,
+    Enum: lambda o: o.value,
+    frozenset: list,
+    deque: list,
+    set: list,
+    Path: str,
+    PurePath: str,
+    UUID: str,
+}
+
+
+def jsonable_encoder(
+    obj: Any,
+    include: Optional[Set[str]] = None,
+    exclude: Optional[Set[str]] = None,
+    by_alias: bool = True,
+    exclude_unset: bool = False,
+    exclude_defaults: bool = False,
+    exclude_none: bool = False,
+    custom_encoder: Optional[Dict[Any, Callable[[Any], Any]]] = None,
+    sqlalchemy_safe: bool = True,
+) -> Any:
+    """
+    Convert any object to a JSON-serializable value (FastAPI-compatible).
+
+    This function is useful for converting complex objects (like Pydantic/dhi models,
+    dataclasses, etc.) to dictionaries that can be serialized to JSON.
+
+    Args:
+        obj: The object to convert
+        include: Set of field names to include (all if None)
+        exclude: Set of field names to exclude
+        by_alias: Use field aliases if available
+        exclude_unset: Exclude fields that were not explicitly set
+        exclude_defaults: Exclude fields with default values
+        exclude_none: Exclude fields with None values
+        custom_encoder: Custom encoders for specific types
+        sqlalchemy_safe: If True, avoid encoding SQLAlchemy lazy-loaded attributes
+
+    Returns:
+        JSON-serializable value
+
+    Usage:
+        from turboapi.encoders import jsonable_encoder
+        from turboapi import BaseModel
+
+        class User(BaseModel):
+            name: str
+            created_at: datetime
+
+        user = User(name="Alice", created_at=datetime.now())
+        json_data = jsonable_encoder(user)
+        # {"name": "Alice", "created_at": "2024-01-01T12:00:00"}
+    """
+    custom_encoder = custom_encoder or {}
+    exclude = exclude or set()
+
+    # Handle None
+    if obj is None:
+        return None
+
+    # Handle dhi BaseModel
+    if HAS_DHI and BaseModel is not None and isinstance(obj, BaseModel):
+        return _encode_model(
+            obj,
+            include=include,
+            exclude=exclude,
+            by_alias=by_alias,
+            exclude_unset=exclude_unset,
+            exclude_defaults=exclude_defaults,
+            exclude_none=exclude_none,
+            custom_encoder=custom_encoder,
+        )
+
+    # Handle Pydantic models
+    if HAS_PYDANTIC:
+        if hasattr(pydantic, "BaseModel") and isinstance(obj, pydantic.BaseModel):
+            return _encode_pydantic(
+                obj,
+                include=include,
+                exclude=exclude,
+                by_alias=by_alias,
+                exclude_unset=exclude_unset,
+                exclude_defaults=exclude_defaults,
+                exclude_none=exclude_none,
+                custom_encoder=custom_encoder,
+            )
+
+    # Handle dataclasses
+    if dataclasses.is_dataclass(obj) and not isinstance(obj, type):
+        return _encode_dataclass(
+            obj,
+            include=include,
+            exclude=exclude,
+            exclude_none=exclude_none,
+            custom_encoder=custom_encoder,
+        )
+
+    # Handle custom encoders
+    if type(obj) in custom_encoder:
+        return custom_encoder[type(obj)](obj)
+
+    # Handle built-in encoders
+    if type(obj) in ENCODERS_BY_TYPE:
+        return ENCODERS_BY_TYPE[type(obj)](obj)
+
+    # Handle dicts
+    if isinstance(obj, dict):
+        return {
+            jsonable_encoder(
+                key,
+                custom_encoder=custom_encoder,
+            ): jsonable_encoder(
+                value,
+                include=include,
+                exclude=exclude,
+                by_alias=by_alias,
+                exclude_unset=exclude_unset,
+                exclude_defaults=exclude_defaults,
+                exclude_none=exclude_none,
+                custom_encoder=custom_encoder,
+            )
+            for key, value in obj.items()
+            if not (exclude_none and value is None)
+        }
+
+    # Handle lists, tuples, sets, frozensets
+    if isinstance(obj, (list, tuple, set, frozenset, deque)):
+        return [
+            jsonable_encoder(
+                item,
+                include=include,
+                exclude=exclude,
+                by_alias=by_alias,
+                exclude_unset=exclude_unset,
+                exclude_defaults=exclude_defaults,
+                exclude_none=exclude_none,
+                custom_encoder=custom_encoder,
+            )
+            for item in obj
+        ]
+
+    # Handle Enum
+    if isinstance(obj, Enum):
+        return obj.value
+
+    # Handle primitives
+    if isinstance(obj, (str, int, float, bool)):
+        return obj
+
+    # Handle objects with __dict__
+    if hasattr(obj, "__dict__"):
+        data = {}
+        for key, value in obj.__dict__.items():
+            if key.startswith("_"):
+                continue
+            if sqlalchemy_safe and key.startswith("_sa_"):
+                continue
+            if exclude and key in exclude:
+                continue
+            if include is not None and key not in include:
+                continue
+            if exclude_none and value is None:
+                continue
+            data[key] = jsonable_encoder(
+                value,
+                by_alias=by_alias,
+                exclude_unset=exclude_unset,
+                exclude_defaults=exclude_defaults,
+                exclude_none=exclude_none,
+                custom_encoder=custom_encoder,
+            )
+        return data
+
+    # Fallback: try to convert to string
+    try:
+        return str(obj)
+    except Exception:
+        return repr(obj)
+
+
+def _encode_model(
+    obj: Any,
+    include: Optional[Set[str]],
+    exclude: Set[str],
+    by_alias: bool,
+    exclude_unset: bool,
+    exclude_defaults: bool,
+    exclude_none: bool,
+    custom_encoder: Dict[Any, Callable[[Any], Any]],
+) -> Dict[str, Any]:
+    """Encode a dhi BaseModel to a dict."""
+    # Use model_dump if available
+    if hasattr(obj, "model_dump"):
+        # Try with full parameters (Pydantic v2 style)
+        try:
+            data = obj.model_dump(
+                include=include,
+                exclude=exclude,
+                by_alias=by_alias,
+                exclude_unset=exclude_unset,
+                exclude_defaults=exclude_defaults,
+                exclude_none=exclude_none,
+            )
+        except TypeError:
+            # Fallback for dhi or simpler model_dump implementations
+            data = obj.model_dump()
+    else:
+        # Fallback to dict() or __dict__
+        data = dict(obj) if hasattr(obj, "__iter__") else vars(obj).copy()
+
+    # Apply include/exclude filters manually if needed
+    if include is not None:
+        data = {k: v for k, v in data.items() if k in include}
+
+    # Recursively encode nested values
+    return {
+        key: jsonable_encoder(value, custom_encoder=custom_encoder)
+        for key, value in data.items()
+        if key not in exclude and not (exclude_none and value is None)
+    }
+
+
+def _encode_pydantic(
+    obj: Any,
+    include: Optional[Set[str]],
+    exclude: Set[str],
+    by_alias: bool,
+    exclude_unset: bool,
+    exclude_defaults: bool,
+    exclude_none: bool,
+    custom_encoder: Dict[Any, Callable[[Any], Any]],
+) -> Dict[str, Any]:
+    """Encode a Pydantic model to a dict."""
+    # Pydantic v2
+    if hasattr(obj, "model_dump"):
+        data = obj.model_dump(
+            include=include,
+            exclude=exclude,
+            by_alias=by_alias,
+            exclude_unset=exclude_unset,
+            exclude_defaults=exclude_defaults,
+            exclude_none=exclude_none,
+        )
+    # Pydantic v1
+    elif hasattr(obj, "dict"):
+        data = obj.dict(
+            include=include,
+            exclude=exclude,
+            by_alias=by_alias,
+            exclude_unset=exclude_unset,
+            exclude_defaults=exclude_defaults,
+            exclude_none=exclude_none,
+        )
+    else:
+        data = vars(obj).copy()
+
+    # Recursively encode nested values
+    return {
+        key: jsonable_encoder(value, custom_encoder=custom_encoder)
+        for key, value in data.items()
+    }
+
+
+def _encode_dataclass(
+    obj: Any,
+    include: Optional[Set[str]],
+    exclude: Set[str],
+    exclude_none: bool,
+    custom_encoder: Dict[Any, Callable[[Any], Any]],
+) -> Dict[str, Any]:
+    """Encode a dataclass to a dict."""
+    data = dataclasses.asdict(obj)
+    return {
+        key: jsonable_encoder(value, custom_encoder=custom_encoder)
+        for key, value in data.items()
+        if key not in exclude
+        and (include is None or key in include)
+        and not (exclude_none and value is None)
+    }
+
+
+__all__ = ["jsonable_encoder", "ENCODERS_BY_TYPE"]

turboapi/exceptions.py

@@ -0,0 +1,111 @@
+"""
+FastAPI-compatible exception classes for TurboAPI.
+"""
+
+from typing import Any, Dict, List, Optional, Sequence, Union
+
+
+class HTTPException(Exception):
+    """
+    HTTP exception for API errors.
+
+    Usage:
+        raise HTTPException(status_code=404, detail="Item not found")
+    """
+
+    def __init__(
+        self,
+        status_code: int,
+        detail: Any = None,
+        headers: Optional[Dict[str, str]] = None,
+    ):
+        self.status_code = status_code
+        self.detail = detail
+        self.headers = headers
+
+
+class RequestValidationError(Exception):
+    """
+    Request validation error (FastAPI-compatible).
+
+    Raised when request data fails validation.
+
+    Usage:
+        from turboapi import RequestValidationError
+
+        @app.exception_handler(RequestValidationError)
+        async def validation_exception_handler(request, exc):
+            return JSONResponse(
+                status_code=422,
+                content={"detail": exc.errors()}
+            )
+    """
+
+    def __init__(
+        self,
+        errors: Sequence[Any],
+        *,
+        body: Any = None,
+    ):
+        self._errors = errors
+        self.body = body
+
+    def errors(self) -> List[Dict[str, Any]]:
+        """Return list of validation errors."""
+        return list(self._errors)
+
+
+class WebSocketException(Exception):
+    """
+    WebSocket exception (FastAPI-compatible).
+
+    Raised when a WebSocket error occurs.
+
+    Usage:
+        raise WebSocketException(code=1008, reason="Policy violation")
+    """
+
+    def __init__(
+        self,
+        code: int = 1000,
+        reason: Optional[str] = None,
+    ):
+        self.code = code
+        self.reason = reason
+
+
+class ValidationError(Exception):
+    """
+    Generic validation error.
+
+    Provides a base for validation-related exceptions.
+    """
+
+    def __init__(
+        self,
+        errors: List[Dict[str, Any]],
+    ):
+        self._errors = errors
+
+    def errors(self) -> List[Dict[str, Any]]:
+        """Return list of validation errors."""
+        return self._errors
+
+
+class StarletteHTTPException(HTTPException):
+    """
+    Starlette-compatible HTTP exception alias.
+
+    Some applications expect this for compatibility.
+    """
+
+    pass
+
+
+__all__ = [
+    "HTTPException",
+    "RequestValidationError",
+    "WebSocketException",
+    "ValidationError",
+    "StarletteHTTPException",
+]

turboapi/main_app.py

@@ -4,9 +4,11 @@ FastAPI-compatible application with revolutionary performance
 """
 
 import asyncio
+import contextlib
 import inspect
-from collections.abc import Callable
-from typing import Any
+import json
+from collections.abc import AsyncGenerator, Callable
+from typing import Any, Optional
 
 from .routing import Router
 from .version_check import CHECK_MARK, ROCKET
@@ -20,6 +22,10 @@ class TurboAPI(Router):
         title: str = "TurboAPI",
         version: str = "0.1.0",
         description: str = "A revolutionary Python web framework",
+        docs_url: Optional[str] = "/docs",
+        redoc_url: Optional[str] = "/redoc",
+        openapi_url: Optional[str] = "/openapi.json",
+        lifespan: Optional[Callable] = None,
         **kwargs
     ):
         super().__init__()
@@ -29,6 +35,14 @@ class TurboAPI(Router):
         self.middleware_stack = []
         self.startup_handlers = []
         self.shutdown_handlers = []
+        self.docs_url = docs_url
+        self.redoc_url = redoc_url
+        self.openapi_url = openapi_url
+        self._lifespan = lifespan
+        self._mounts: dict[str, Any] = {}
+        self._websocket_routes: dict[str, Callable] = {}
+        self._exception_handlers: dict[type, Callable] = {}
+        self._openapi_schema: Optional[dict] = None
 
         print(f"{ROCKET} TurboAPI application created: {title} v{version}")
 
@@ -65,8 +79,49 @@ class TurboAPI(Router):
         super().include_router(router, prefix, tags)
         print(f"[ROUTER] Included router with prefix: {prefix}")
 
-    # FastAPI-like decorators for better developer experience (inherits from Router)
-    # The decorators are already available from the Router base class
+    def mount(self, path: str, app: Any, name: Optional[str] = None) -> None:
+        """Mount a sub-application or static files at a path.
+
+        Usage:
+            app.mount("/static", StaticFiles(directory="static"), name="static")
+        """
+        self._mounts[path] = {"app": app, "name": name}
+        print(f"[MOUNT] Mounted {name or 'app'} at {path}")
+
+    def websocket(self, path: str):
+        """Register a WebSocket endpoint.
+
+        Usage:
+            @app.websocket("/ws")
+            async def websocket_endpoint(websocket: WebSocket):
+                await websocket.accept()
+                data = await websocket.receive_text()
+                await websocket.send_text(f"Echo: {data}")
+        """
+        def decorator(func: Callable):
+            self._websocket_routes[path] = func
+            return func
+        return decorator
+
+    def exception_handler(self, exc_class: type):
+        """Register a custom exception handler.
+
+        Usage:
+            @app.exception_handler(ValueError)
+            async def value_error_handler(request, exc):
+                return JSONResponse(status_code=400, content={"detail": str(exc)})
+        """
+        def decorator(func: Callable):
+            self._exception_handlers[exc_class] = func
+            return func
+        return decorator
+
+    def openapi(self) -> dict:
+        """Get the OpenAPI schema for this application."""
+        if self._openapi_schema is None:
+            from .openapi import generate_openapi_schema
+            self._openapi_schema = generate_openapi_schema(self)
+        return self._openapi_schema
 
     async def _run_startup_handlers(self):
         """Run all startup event handlers."""

turboapi/middleware.py

@@ -171,14 +171,12 @@ class GZipMiddleware(Middleware):
             return response
         
         # Check if response is large enough to compress
-        if hasattr(response, 'content'):
-            content = response.content
-            if isinstance(content, str):
-                content = content.encode('utf-8')
-            
+        if hasattr(response, 'body'):
+            content = response.body
+
             if len(content) < self.minimum_size:
                 return response
-            
+
             # Compress content
             compressed = gzip.compress(content, compresslevel=self.compresslevel)
             response.content = compressed

turboapi/models.py

@@ -1,15 +1,15 @@
 """
-Request and Response models for TurboAPI with Satya integration.
+Request and Response models for TurboAPI with Dhi integration.
 """
 
 import json
 from typing import Any
 
-from satya import Field, Model
+from dhi import BaseModel, Field
 
 
-class TurboRequest(Model):
-    """High-performance HTTP Request model powered by Satya."""
+class TurboRequest(BaseModel):
+    """High-performance HTTP Request model powered by Dhi."""
 
     method: str = Field(description="HTTP method")
     path: str = Field(description="Request path")
@@ -28,17 +28,17 @@ class TurboRequest(Model):
         return default
 
     def json(self) -> Any:
-        """Parse request body as JSON using Satya's fast parsing."""
+        """Parse request body as JSON."""
         if not self.body:
             return None
-        # Use Satya's streaming JSON parsing for performance
         return json.loads(self.body.decode('utf-8'))
 
     def validate_json(self, model_class: type) -> Any:
-        """Validate JSON body against a Satya model."""
+        """Validate JSON body against a Dhi model."""
         if not self.body:
             return None
-        return model_class.model_validate_json_bytes(self.body, streaming=True)
+        data = json.loads(self.body.decode('utf-8'))
+        return model_class.model_validate(data)
 
     def text(self) -> str:
         """Get request body as text."""
@@ -60,39 +60,21 @@ class TurboRequest(Model):
 Request = TurboRequest
 
 
-class TurboResponse(Model):
-    """High-performance HTTP Response model powered by Satya."""
+class TurboResponse(BaseModel):
+    """High-performance HTTP Response model powered by Dhi."""
 
     status_code: int = Field(ge=100, le=599, default=200, description="HTTP status code")
     headers: dict[str, str] = Field(default={}, description="HTTP headers")
     content: Any = Field(default="", description="Response content")
 
-    def __init__(self, **data):
-        # Handle content serialization before validation
-        if 'content' in data:
-            content = data['content']
-            if isinstance(content, dict):
-                # Serialize dict to JSON
-                data['content'] = json.dumps(content)
-                if 'headers' not in data:
-                    data['headers'] = {}
-                data['headers']['content-type'] = 'application/json'
-            elif isinstance(content, (str, int, float, bool)):
-                # Keep as-is, will be converted to string
-                pass
-            elif isinstance(content, bytes):
-                # Convert bytes to string for storage
-                data['content'] = content.decode('utf-8')
-            else:
-                # Convert other types to string
-                data['content'] = str(content)
-
-        super().__init__(**data)
-
     @property
     def body(self) -> bytes:
         """Get response body as bytes."""
-        if isinstance(self.content, str):
+        if isinstance(self.content, dict):
+            return json.dumps(self.content).encode('utf-8')
+        elif isinstance(self.content, (list, tuple)):
+            return json.dumps(self.content).encode('utf-8')
+        elif isinstance(self.content, str):
             return self.content.encode('utf-8')
         elif isinstance(self.content, bytes):
             return self.content