tachyon-api 0.5.11__py3-none-any.whl → 0.6.0__py3-none-any.whl

tachyon_api/processing/responses.py

@@ -0,0 +1,144 @@
+"""
+Response Processing System for Tachyon API
+
+This module handles the processing and serialization of endpoint responses,
+including validation against response models, Struct conversion, and final JSON serialization.
+"""
+
+import asyncio
+from typing import Any, Callable, Dict, Union
+from starlette.responses import Response
+
+import msgspec
+
+from ..schemas.models import Struct
+from ..schemas.responses import (
+    TachyonJSONResponse,
+    response_validation_error_response,
+    internal_server_error_response,
+)
+
+
+class ResponseProcessor:
+    """
+    Handles processing and serialization of endpoint responses.
+
+    This class manages the complete response pipeline:
+    - Calling endpoint functions (sync/async)
+    - Response model validation and conversion
+    - Struct to dict conversion
+    - Final JSON serialization
+    """
+
+    @staticmethod
+    async def process_response(
+        endpoint_func: Callable,
+        kwargs_to_inject: Dict[str, Any],
+        response_model: Any = None,
+    ) -> Union[Response, TachyonJSONResponse]:
+        """
+        Process the complete response pipeline for an endpoint.
+
+        Args:
+            endpoint_func: The endpoint function to call
+            kwargs_to_inject: Arguments to inject into the endpoint function
+            response_model: Optional response model for validation
+
+        Returns:
+            Processed response ready for client
+        """
+        try:
+            # Call the endpoint function
+            payload = await ResponseProcessor._call_endpoint_function(
+                endpoint_func, kwargs_to_inject
+            )
+
+            # If the endpoint already returned a Response object, return it directly
+            if isinstance(payload, Response):
+                return payload
+
+            # Validate/convert response against response_model if provided
+            if response_model is not None:
+                validation_result = ResponseProcessor._validate_response_model(
+                    payload, response_model
+                )
+                if isinstance(validation_result, TachyonJSONResponse):
+                    return validation_result  # Error response
+                payload = validation_result
+
+            # Convert Struct objects to dictionaries for JSON serialization
+            payload = ResponseProcessor._convert_structs_to_dicts(payload)
+
+            return TachyonJSONResponse(payload)
+
+        except Exception:
+            # Fallback: prevent unhandled exceptions from leaking to the client
+            return internal_server_error_response()
+
+    @staticmethod
+    async def _call_endpoint_function(
+        endpoint_func: Callable, kwargs_to_inject: Dict[str, Any]
+    ) -> Any:
+        """
+        Call the endpoint function with injected parameters.
+
+        Handles both sync and async endpoint functions.
+
+        Args:
+            endpoint_func: The endpoint function to call
+            kwargs_to_inject: Arguments to inject
+
+        Returns:
+            Result of calling the endpoint function
+        """
+        if asyncio.iscoroutinefunction(endpoint_func):
+            payload = await endpoint_func(**kwargs_to_inject)
+        else:
+            payload = endpoint_func(**kwargs_to_inject)
+        return payload
+
+    @staticmethod
+    def _validate_response_model(
+        payload: Any, response_model: Any
+    ) -> Union[Any, TachyonJSONResponse]:
+        """
+        Validate and convert response against the response model.
+
+        Args:
+            payload: The response payload to validate
+            response_model: The expected response model
+
+        Returns:
+            Validated and converted payload, or error response on validation failure
+        """
+        try:
+            return msgspec.convert(payload, response_model)
+        except Exception as e:
+            return response_validation_error_response(str(e))
+
+    @staticmethod
+    def _convert_structs_to_dicts(payload: Any) -> Any:
+        """
+        Convert Struct objects to dictionaries for JSON serialization.
+
+        Handles both single Struct objects and dictionaries containing Struct values.
+
+        Args:
+            payload: The payload that may contain Struct objects
+
+        Returns:
+            Payload with Struct objects converted to dictionaries
+        """
+        if isinstance(payload, Struct):
+            return msgspec.to_builtins(payload)
+        elif isinstance(payload, dict):
+            # Convert any Struct values in the dictionary
+            converted_payload = {}
+            for key, value in payload.items():
+                if isinstance(value, Struct):
+                    converted_payload[key] = msgspec.to_builtins(value)
+                else:
+                    converted_payload[key] = value
+            return converted_payload
+        else:
+            return payload

tachyon_api/routing/__init__.py

@@ -0,0 +1,8 @@
+"""
+Tachyon API routing system.
+"""
+
+from .routes import TachyonRoute, TachyonRouter
+from .router import Router
+
+__all__ = ["TachyonRoute", "TachyonRouter", "Router"]

tachyon_api/{router.py → routing/router.py}

@@ -8,7 +8,7 @@ allowing for better organization of routes with common prefixes, tags, and depen
 from functools import partial
 from typing import List, Optional, Any, Callable, Dict
 
-from .di import Depends
+from ..dependencies.injection import Depends
 
 
 class Router:

tachyon_api/routing/routes.py

@@ -0,0 +1,243 @@
+"""
+Starlette-Native Routes for Tachyon API
+
+This module provides route classes that extend Starlette's routing system
+while maintaining Tachyon's functionality for dependency injection and parameter processing.
+"""
+
+import inspect
+from typing import Any, Callable
+from starlette.responses import JSONResponse
+from starlette.routing import Route
+
+from ..dependencies.injection import _registry, Depends
+from ..processing.parameters import ParameterProcessor, _NotProcessed
+from ..processing.responses import ResponseProcessor
+from ..dependencies.resolver import DependencyResolver
+
+
+class TachyonRoute(Route):
+    """
+    Starlette-native route that encapsulates Tachyon's functionality.
+
+    This route extends Starlette's Route class while providing:
+    - Dependency injection
+    - Parameter processing (Body, Query, Path)
+    - Response processing
+    - Error handling
+
+    This makes the routing system more Starlette-compatible while maintaining
+    all of Tachyon's features.
+    """
+
+    def __init__(
+        self,
+        path: str,
+        endpoint: Callable,
+        *,
+        methods: list = None,
+        name: str = None,
+        include_in_schema: bool = True,
+        response_model: Any = None,
+        dependency_resolver: DependencyResolver = None,
+        **kwargs,
+    ):
+        """
+        Initialize a Tachyon route.
+
+        Args:
+            path: URL path pattern
+            endpoint: Endpoint function
+            methods: HTTP methods (defaults to ['GET'])
+            name: Route name
+            include_in_schema: Whether to include in OpenAPI schema
+            response_model: Response model for validation
+            dependency_resolver: Dependency resolver instance
+            **kwargs: Additional route options
+        """
+        # Store Tachyon-specific configuration
+        self.endpoint = endpoint
+        self.response_model = response_model
+        self.include_in_schema = include_in_schema
+        self._dependency_resolver = dependency_resolver or DependencyResolver()
+        self._route_kwargs = kwargs
+
+        # Create the actual handler function
+        handler = self._create_handler()
+
+        # Initialize parent Route with our handler
+        super().__init__(
+            path=path,
+            endpoint=handler,
+            methods=methods or ["GET"],
+            name=name,
+        )
+
+    def _create_handler(self) -> Callable:
+        """
+        Create the async handler function that will be used by Starlette.
+
+        This handler encapsulates all of Tachyon's functionality:
+        - Parameter processing
+        - Dependency injection
+        - Response processing
+        - Error handling
+
+        Returns:
+            Async handler function compatible with Starlette
+        """
+
+        async def handler(request):
+            """
+            Async request handler that processes parameters and calls the endpoint.
+
+            This handler analyzes the endpoint function signature and automatically
+            injects the appropriate values based on parameter annotations and defaults.
+            """
+            try:
+                # Process function signature and inject parameters
+                kwargs_to_inject = await self._process_parameters(request)
+
+                # Process the response using ResponseProcessor
+                return await ResponseProcessor.process_response(
+                    self.endpoint, kwargs_to_inject, self.response_model
+                )
+
+            except Exception:
+                # Fallback: prevent unhandled exceptions from leaking to the client
+                from .responses import internal_server_error_response
+
+                return internal_server_error_response()
+
+        return handler
+
+    async def _process_parameters(self, request) -> dict:
+        """
+        Process endpoint parameters and inject dependencies.
+
+        Args:
+            request: Starlette request object
+
+        Returns:
+            Dictionary of parameters to inject into the endpoint function
+        """
+        kwargs_to_inject = {}
+        sig = inspect.signature(self.endpoint)
+        query_params = request.query_params
+        path_params = request.path_params
+        _raw_body = None
+
+        # Process each parameter in the endpoint function signature
+        for param in sig.parameters.values():
+            # Determine if this parameter is a dependency
+            is_explicit_dependency = isinstance(param.default, Depends)
+            is_implicit_dependency = (
+                param.default is inspect.Parameter.empty
+                and param.annotation in _registry
+            )
+
+            # Process dependencies (explicit and implicit)
+            if is_explicit_dependency or is_implicit_dependency:
+                target_class = param.annotation
+                kwargs_to_inject[param.name] = (
+                    self._dependency_resolver.resolve_dependency(target_class)
+                )
+                continue
+
+            # Process other parameter types using ParameterProcessor
+            result = await ParameterProcessor.process_parameter(
+                param,
+                request,
+                path_params,
+                query_params,
+                _raw_body,
+                is_explicit_dependency,
+                is_implicit_dependency,
+            )
+
+            # If parameter was processed and returned a value/error, handle it
+            if not isinstance(result, _NotProcessed):
+                if isinstance(result, JSONResponse):
+                    raise Exception(
+                        "Parameter processing error"
+                    )  # Will be caught by handler
+                kwargs_to_inject[param.name] = result
+
+        return kwargs_to_inject
+
+    def get_endpoint_info(self) -> dict:
+        """
+        Get endpoint information for OpenAPI generation and introspection.
+
+        Returns:
+            Dictionary with endpoint metadata
+        """
+        return {
+            "path": self.path,
+            "method": self.methods[0] if self.methods else "GET",
+            "func": self.endpoint,
+            "response_model": self.response_model,
+            "include_in_schema": self.include_in_schema,
+            **self._route_kwargs,
+        }
+
+
+class TachyonRouter:
+    """
+    Starlette-native router that manages Tachyon routes.
+
+    This router provides a clean interface for registering routes
+    while maintaining full compatibility with Starlette's routing system.
+    """
+
+    def __init__(self, dependency_resolver: DependencyResolver = None):
+        """
+        Initialize the Tachyon router.
+
+        Args:
+            dependency_resolver: Dependency resolver instance (optional)
+        """
+        self.routes = []
+        self._dependency_resolver = dependency_resolver or DependencyResolver()
+
+    def add_route(
+        self,
+        path: str,
+        endpoint: Callable,
+        methods: list = None,
+        name: str = None,
+        **kwargs,
+    ) -> TachyonRoute:
+        """
+        Add a route to the router.
+
+        Args:
+            path: URL path pattern
+            endpoint: Endpoint function
+            methods: HTTP methods
+            name: Route name
+            **kwargs: Additional route options
+
+        Returns:
+            Created TachyonRoute instance
+        """
+        route = TachyonRoute(
+            path=path,
+            endpoint=endpoint,
+            methods=methods,
+            name=name,
+            dependency_resolver=self._dependency_resolver,
+            **kwargs,
+        )
+
+        self.routes.append(route)
+        return route
+
+    def get_starlette_routes(self) -> list:
+        """
+        Get all routes in Starlette-compatible format.
+
+        Returns:
+            List of Starlette Route objects
+        """
+        return self.routes

tachyon_api/schemas/__init__.py

@@ -0,0 +1,17 @@
+"""
+Tachyon API schemas and data models.
+"""
+
+from .models import Struct
+from .parameters import Query, Body, Path
+from .responses import TachyonJSONResponse, success_response, error_response
+
+__all__ = [
+    "Struct",
+    "Query",
+    "Body",
+    "Path",
+    "TachyonJSONResponse",
+    "success_response",
+    "error_response",
+]

tachyon_api/utils/type_converter.py

@@ -9,7 +9,7 @@ to typed values expected by endpoint functions.
 from typing import Type, Union, Any
 from starlette.responses import JSONResponse
 
-from ..responses import validation_error_response
+from ..schemas.responses import validation_error_response
 from .type_utils import TypeUtils
 
 

{tachyon_api-0.5.11.dist-info → tachyon_api-0.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: tachyon-api
-Version: 0.5.11
+Version: 0.6.0
 Summary: A lightweight, FastAPI-inspired web framework
 License: GPL-3.0-or-later
 Author: Juan Manuel Panozzo Zénere
@@ -22,7 +22,7 @@ Description-Content-Type: text/markdown
 
 # 🚀 Tachyon API
 
-![Version](https://img.shields.io/badge/version-0.5.7-blue.svg)
+![Version](https://img.shields.io/badge/version-0.6.0-blue.svg)
 ![Python](https://img.shields.io/badge/python-3.10+-brightgreen.svg)
 ![License](https://img.shields.io/badge/license-GPL--3.0-orange.svg)
 ![Status](https://img.shields.io/badge/status-stable-brightgreen.svg)
@@ -31,9 +31,10 @@ Description-Content-Type: text/markdown
 
 Tachyon API combines the intuitive decorator-based syntax you love with minimal dependencies and maximal performance. Built with Test-Driven Development from the ground up, it offers a cleaner, faster alternative with full ASGI compatibility.
 
+**✨ v0.6.0 introduces Starlette-Native Architecture**: Maximum Starlette compatibility for seamless future Rust migration while maintaining all Tachyon features.
+
 ```python
-from tachyon_api import Tachyon
-from tachyon_api.models import Struct
+from tachyon_api import Tachyon, Struct
 
 app = Tachyon()
 
@@ -63,6 +64,7 @@ def create_user(user: User):
 - 🧰 Default JSON response (TachyonJSONResponse)
 - 🔒 End-to-end safety: request Body validation + typed response_model
 - 📘 Deep OpenAPI schemas: nested Structs, Optional/List (nullable/array), formats (uuid, date-time)
+- 🏗️ **Starlette-Native Architecture** (v0.6.0): Maximum compatibility for future Rust migration
 
 ## 🧪 Test-Driven Development
 

tachyon_api-0.6.0.dist-info/RECORD

@@ -0,0 +1,33 @@
+tachyon_api/__init__.py,sha256=Z9ylLDxU416uUdyDRilmUOAxNiVeiLybvVbqIuyssMc,1269
+tachyon_api/core/__init__.py,sha256=G9SXqh-lbVCnFlcV83aM4T05HNGlzMr-3WVF3irx4_M,86
+tachyon_api/core/app.py,sha256=-HYRhbLeXA4YOjh-0Gl2c1RtSFwGmIHft0Y8Wmr-F_c,13521
+tachyon_api/dependencies/__init__.py,sha256=MXXhWXIbREA9lgNLyObjj3G9g4q9PF6e76lIpvls3MQ,217
+tachyon_api/dependencies/injection.py,sha256=FyFghfUjU0OaE_lW2BqItgsZWXFbLvwFsvVywqFjl6c,1505
+tachyon_api/dependencies/resolver.py,sha256=HsFdndwa4wd2jdTaV_ztz1Vr3rrBgUngIuOJmwgXhS0,2795
+tachyon_api/features/__init__.py,sha256=ERv3157ho83DLwiyB3hUF_hqTf7CigfcndOq-0tv5HM,622
+tachyon_api/features/cache.py,sha256=IIdg9yTiNuc9CEgV33yLXz9ssmHqI9IiqMilRbM-aZ8,8312
+tachyon_api/middlewares/__init__.py,sha256=MkO5xgCMScI_lz1mdFv4oGauAfVYiNGsCbE22FgGiFg,390
+tachyon_api/middlewares/core.py,sha256=-dJTrI6KJbQzatopCUC5lau_JIZpl063697qdE4W0SY,1440
+tachyon_api/middlewares/cors.py,sha256=IzaedBdUCOYsQpMhZRN3mAzDevvQVnKDYzMrqY56bNA,6068
+tachyon_api/middlewares/logger.py,sha256=TcYcfBuc8iBGZZIW6aMvJ_foFD7by9vM_EsHnhH9E_Y,4908
+tachyon_api/middlewares/manager.py,sha256=Mm0uSfio0OqhOsOGDCwVJmgPJMrvHxxen4n9mm81zWA,2280
+tachyon_api/openapi/__init__.py,sha256=qDMsg68WUVhScRlkkOjpMZUX0U0JVsxdT9f-j3DHSNo,462
+tachyon_api/openapi/builder.py,sha256=jLOwYywk_OeMKY2ffSYHKk_rrl23UvV24Wz45gNNfnA,11955
+tachyon_api/openapi/schema.py,sha256=GFkehWZo2ndm7URD3rqa0SAcf4g427k1Nt-0JlkKc-w,14502
+tachyon_api/processing/__init__.py,sha256=_DMpR6UHgfmUBZU-zBD9OazVAie1Hnv-ZkDE7zDA_s4,221
+tachyon_api/processing/parameters.py,sha256=-d7cCNiObs396XUw1hseg1XV-fH5OEOTC9us-CV6aEA,11702
+tachyon_api/processing/responses.py,sha256=hml1S7iqA2bTjVQf0arN4RE03bZZ4IhI6uxmR_u9lNs,4824
+tachyon_api/routing/__init__.py,sha256=d47zBabWzT85kWnFJsDz_0_884OjwePJAPpa0zo_4oY,167
+tachyon_api/routing/router.py,sha256=xXPkwHkdgfBDk-9RK3ZYBTM1nymT7BBzGuXo1peVyRY,4225
+tachyon_api/routing/routes.py,sha256=-jaIpdP5tRV0JP_n7zkruRq6URWoCRutJRXZbCGWpAE,7802
+tachyon_api/schemas/__init__.py,sha256=3zi89F161Na0fNJI_DG7k3A2GNjqcdi8d2N4JqWHtR4,331
+tachyon_api/schemas/models.py,sha256=9pA5_ddMAcWW2dErAgeyG926NFezfCU68uuhW0qGMs4,2224
+tachyon_api/schemas/parameters.py,sha256=gLGIsFEGr33_G0kakpqOFHRrf86w3egFJAjquZp3Lo0,2810
+tachyon_api/schemas/responses.py,sha256=vFH8RsQxsuOoaSE6hBh1_UhXC_jdFyBdeYyMYDtIuDg,2945
+tachyon_api/utils/__init__.py,sha256=O-GmW5oTbG10TRz2q3NCzAQD3FBZrUn65qf8mywM47M,347
+tachyon_api/utils/type_converter.py,sha256=cV2FXdG6Pz7Eev0sPOF5-63YR4NFRUmuu2KxEwFmm7Y,4159
+tachyon_api/utils/type_utils.py,sha256=Bovpofif-gH6Q-ehmZrauMMHWSypQgiu6tsjHV3UtTU,3351
+tachyon_api-0.6.0.dist-info/LICENSE,sha256=UZXUTSuWBt8V377-2_YE4ug9t6rcBAKrfOVhIBQ8zhk,712
+tachyon_api-0.6.0.dist-info/METADATA,sha256=vMAfI6OES3Jbhu0qWODJks7sMqHIPiKZl2fb4UxQ0Bg,5549
+tachyon_api-0.6.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+tachyon_api-0.6.0.dist-info/RECORD,,