tachyon-api 0.9.0__py3-none-any.whl

tachyon_api/cli/templates/service.py

@@ -0,0 +1,330 @@
+"""
+Service module templates.
+"""
+
+
+class ServiceTemplates:
+    """Templates for `tachyon generate service` command."""
+
+    @staticmethod
+    def init(snake_name: str, class_name: str) -> str:
+        return f'''"""
+{class_name} module.
+"""
+
+from .{snake_name}_controller import router
+from .{snake_name}_service import {class_name}Service
+from .{snake_name}_repository import {class_name}Repository
+
+__all__ = ["router", "{class_name}Service", "{class_name}Repository"]
+'''
+
+    @staticmethod
+    def controller(snake_name: str, class_name: str, crud: bool = False) -> str:
+        if crud:
+            return f'''"""
+{class_name} Controller - HTTP endpoints.
+"""
+
+from typing import List
+from tachyon_api import Router, Depends, Query
+from .{snake_name}_service import {class_name}Service
+from .{snake_name}_dto import (
+    {class_name}Response,
+    {class_name}Create,
+    {class_name}Update,
+)
+
+router = Router(prefix="/{snake_name}s", tags=["{class_name}"])
+
+
+@router.get("/", response_model=List[{class_name}Response])
+def list_{snake_name}s(
+    skip: int = Query(0),
+    limit: int = Query(100),
+    service: {class_name}Service = Depends(),
+):
+    """List all {snake_name}s with pagination."""
+    return service.find_all(skip=skip, limit=limit)
+
+
+@router.get("/{{id}}", response_model={class_name}Response)
+def get_{snake_name}(
+    id: str,
+    service: {class_name}Service = Depends(),
+):
+    """Get a {snake_name} by ID."""
+    return service.find_by_id(id)
+
+
+@router.post("/", response_model={class_name}Response)
+def create_{snake_name}(
+    data: {class_name}Create,
+    service: {class_name}Service = Depends(),
+):
+    """Create a new {snake_name}."""
+    return service.create(data)
+
+
+@router.put("/{{id}}", response_model={class_name}Response)
+def update_{snake_name}(
+    id: str,
+    data: {class_name}Update,
+    service: {class_name}Service = Depends(),
+):
+    """Update a {snake_name}."""
+    return service.update(id, data)
+
+
+@router.delete("/{{id}}")
+def delete_{snake_name}(
+    id: str,
+    service: {class_name}Service = Depends(),
+):
+    """Delete a {snake_name}."""
+    service.delete(id)
+    return {{"deleted": True}}
+'''
+        else:
+            return f'''"""
+{class_name} Controller - HTTP endpoints.
+"""
+
+from tachyon_api import Router, Depends
+from .{snake_name}_service import {class_name}Service
+from .{snake_name}_dto import {class_name}Response
+
+router = Router(prefix="/{snake_name}s", tags=["{class_name}"])
+
+
+@router.get("/", response_model={class_name}Response)
+def get_{snake_name}s(
+    service: {class_name}Service = Depends(),
+):
+    """Get {snake_name}s."""
+    return service.get_all()
+'''
+
+    @staticmethod
+    def service(snake_name: str, class_name: str, crud: bool = False) -> str:
+        if crud:
+            return f'''"""
+{class_name} Service - Business logic.
+"""
+
+from typing import List, Optional
+from tachyon_api import injectable, HTTPException
+from .{snake_name}_repository import {class_name}Repository
+from .{snake_name}_dto import {class_name}Create, {class_name}Update
+
+
+@injectable
+class {class_name}Service:
+    """
+    {class_name} business logic.
+    
+    Handles validation, business rules, and orchestrates repository calls.
+    """
+
+    def __init__(self, repository: {class_name}Repository):
+        self.repository = repository
+
+    def find_all(self, skip: int = 0, limit: int = 100) -> List[dict]:
+        """Get all {snake_name}s with pagination."""
+        return self.repository.find_all(skip=skip, limit=limit)
+
+    def find_by_id(self, id: str) -> dict:
+        """Get a {snake_name} by ID."""
+        result = self.repository.find_by_id(id)
+        if not result:
+            raise HTTPException(status_code=404, detail="{class_name} not found")
+        return result
+
+    def create(self, data: {class_name}Create) -> dict:
+        """Create a new {snake_name}."""
+        return self.repository.create(data)
+
+    def update(self, id: str, data: {class_name}Update) -> dict:
+        """Update a {snake_name}."""
+        existing = self.find_by_id(id)
+        return self.repository.update(id, data)
+
+    def delete(self, id: str) -> None:
+        """Delete a {snake_name}."""
+        self.find_by_id(id)  # Verify exists
+        self.repository.delete(id)
+'''
+        else:
+            return f'''"""
+{class_name} Service - Business logic.
+"""
+
+from tachyon_api import injectable
+from .{snake_name}_repository import {class_name}Repository
+
+
+@injectable
+class {class_name}Service:
+    """
+    {class_name} business logic.
+    
+    Handles validation, business rules, and orchestrates repository calls.
+    """
+
+    def __init__(self, repository: {class_name}Repository):
+        self.repository = repository
+
+    def get_all(self) -> dict:
+        """Get all {snake_name}s."""
+        items = self.repository.find_all()
+        return {{"items": items, "count": len(items)}}
+'''
+
+    @staticmethod
+    def repository(snake_name: str, class_name: str, crud: bool = False) -> str:
+        if crud:
+            return f'''"""
+{class_name} Repository - Data access layer.
+"""
+
+from typing import List, Optional
+from tachyon_api import injectable
+
+
+@injectable
+class {class_name}Repository:
+    """
+    {class_name} data access.
+    
+    Handles database operations. Replace with actual DB implementation.
+    """
+
+    def __init__(self):
+        # TODO: Replace with actual database connection
+        self._data: dict = {{}}
+
+    def find_all(self, skip: int = 0, limit: int = 100) -> List[dict]:
+        """Get all {snake_name}s with pagination."""
+        items = list(self._data.values())
+        return items[skip:skip + limit]
+
+    def find_by_id(self, id: str) -> Optional[dict]:
+        """Find a {snake_name} by ID."""
+        return self._data.get(id)
+
+    def create(self, data) -> dict:
+        """Create a new {snake_name}."""
+        import uuid
+        id = str(uuid.uuid4())
+        item = {{"id": id, **data.__dict__}}
+        self._data[id] = item
+        return item
+
+    def update(self, id: str, data) -> dict:
+        """Update a {snake_name}."""
+        item = self._data.get(id, {{}})
+        for key, value in data.__dict__.items():
+            if value is not None:
+                item[key] = value
+        self._data[id] = item
+        return item
+
+    def delete(self, id: str) -> None:
+        """Delete a {snake_name}."""
+        self._data.pop(id, None)
+'''
+        else:
+            return f'''"""
+{class_name} Repository - Data access layer.
+"""
+
+from typing import List
+from tachyon_api import injectable
+
+
+@injectable
+class {class_name}Repository:
+    """
+    {class_name} data access.
+    
+    Handles database operations. Replace with actual DB implementation.
+    """
+
+    def __init__(self):
+        # TODO: Replace with actual database connection
+        pass
+
+    def find_all(self) -> List[dict]:
+        """Get all {snake_name}s."""
+        # TODO: Implement database query
+        return []
+'''
+
+    @staticmethod
+    def dto(snake_name: str, class_name: str, crud: bool = False) -> str:
+        if crud:
+            return f'''"""
+{class_name} DTOs - Data Transfer Objects.
+"""
+
+from typing import Optional
+from tachyon_api import Struct
+
+
+class {class_name}Base(Struct):
+    """Base {snake_name} fields."""
+    name: str
+
+
+class {class_name}Create({class_name}Base):
+    """DTO for creating a {snake_name}."""
+    pass
+
+
+class {class_name}Update(Struct):
+    """DTO for updating a {snake_name}."""
+    name: Optional[str] = None
+
+
+class {class_name}Response({class_name}Base):
+    """DTO for {snake_name} responses."""
+    id: str
+'''
+        else:
+            return f'''"""
+{class_name} DTOs - Data Transfer Objects.
+"""
+
+from typing import List
+from tachyon_api import Struct
+
+
+class {class_name}Response(Struct):
+    """Response DTO for {snake_name}."""
+    items: List[dict]
+    count: int
+'''
+
+    @staticmethod
+    def test_service(snake_name: str, class_name: str) -> str:
+        return f'''"""
+Tests for {class_name}Service.
+"""
+
+import pytest
+
+
+class Test{class_name}Service:
+    """Unit tests for {class_name}Service."""
+
+    def test_placeholder(self):
+        """Placeholder test - implement your tests here."""
+        # TODO: Implement actual tests
+        # from modules.{snake_name} import {class_name}Service, {class_name}Repository
+        # 
+        # repository = {class_name}Repository()
+        # service = {class_name}Service(repository)
+        # result = service.get_all()
+        # assert result is not None
+        assert True
+'''

tachyon_api/core/__init__.py

@@ -0,0 +1,12 @@
+"""
+Core functionality for Tachyon API.
+
+This module contains the core components of the framework:
+- lifecycle: Application startup/shutdown event handling
+- websocket: WebSocket route handling
+"""
+
+from .lifecycle import LifecycleManager
+from .websocket import WebSocketManager
+
+__all__ = ["LifecycleManager", "WebSocketManager"]

tachyon_api/core/lifecycle.py

@@ -0,0 +1,106 @@
+"""
+Lifecycle event management for Tachyon applications.
+
+Handles:
+- User-provided lifespan context managers
+- @app.on_event('startup') handlers
+- @app.on_event('shutdown') handlers
+"""
+
+import asyncio
+from contextlib import asynccontextmanager
+from typing import Callable, List, Optional
+
+
+class LifecycleManager:
+    """
+    Manages application lifecycle events (startup/shutdown).
+    
+    This class encapsulates the logic for:
+    - Registering startup/shutdown handlers via decorators
+    - Combining user-provided lifespan with event handlers
+    - Executing handlers in the correct order
+    """
+    
+    def __init__(self, user_lifespan: Optional[Callable] = None):
+        """
+        Initialize lifecycle manager.
+        
+        Args:
+            user_lifespan: Optional async context manager for startup/shutdown
+        """
+        self._user_lifespan = user_lifespan
+        self._startup_handlers: List[Callable] = []
+        self._shutdown_handlers: List[Callable] = []
+    
+    def create_combined_lifespan(self):
+        """
+        Create a combined lifespan context manager that handles both
+        user-provided lifespan and on_event handlers.
+
+        Note: This returns a factory that captures `self` and dynamically
+        accesses handlers at runtime (not at definition time).
+        
+        Returns:
+            An async context manager function compatible with Starlette
+        """
+        lifecycle_manager = self
+
+        @asynccontextmanager
+        async def combined_lifespan(app):
+            # Run startup handlers (accessed dynamically)
+            for handler in lifecycle_manager._startup_handlers:
+                if asyncio.iscoroutinefunction(handler):
+                    await handler()
+                else:
+                    handler()
+
+            # Run user-provided lifespan if any
+            if lifecycle_manager._user_lifespan is not None:
+                # Pass the app to user lifespan (it expects the Tachyon app)
+                async with lifecycle_manager._user_lifespan(app):
+                    yield
+            else:
+                yield
+
+            # Run shutdown handlers (accessed dynamically)
+            for handler in lifecycle_manager._shutdown_handlers:
+                if asyncio.iscoroutinefunction(handler):
+                    await handler()
+                else:
+                    handler()
+
+        return combined_lifespan
+    
+    def on_event_decorator(self, event_type: str):
+        """
+        Create a decorator to register startup or shutdown event handlers.
+
+        Args:
+            event_type: Either 'startup' or 'shutdown'
+
+        Returns:
+            A decorator that registers the handler function
+
+        Example:
+            @app.on_event('startup')
+            async def on_startup():
+                print('Starting up...')
+
+            @app.on_event('shutdown')
+            def on_shutdown():
+                print('Shutting down...')
+        """
+
+        def decorator(func: Callable):
+            if event_type == "startup":
+                self._startup_handlers.append(func)
+            elif event_type == "shutdown":
+                self._shutdown_handlers.append(func)
+            else:
+                raise ValueError(
+                    f"Invalid event type: {event_type}. Use 'startup' or 'shutdown'."
+                )
+            return func
+
+        return decorator

tachyon_api/core/websocket.py

@@ -0,0 +1,92 @@
+"""
+WebSocket handling for Tachyon applications.
+
+Handles:
+- WebSocket route registration
+- Path parameter injection
+- WebSocket handler wrapping
+"""
+
+import inspect
+from typing import Callable
+
+from starlette.routing import WebSocketRoute
+from starlette.websockets import WebSocket
+
+
+class WebSocketManager:
+    """
+    Manages WebSocket routes and handlers.
+    
+    This class encapsulates the logic for:
+    - Registering WebSocket endpoints via decorator
+    - Wrapping user handlers with parameter injection
+    - Path parameter extraction and injection
+    """
+    
+    def __init__(self, router):
+        """
+        Initialize WebSocket manager.
+        
+        Args:
+            router: The Starlette router instance
+        """
+        self._router = router
+    
+    def websocket_decorator(self, path: str):
+        """
+        Create a decorator to register a WebSocket endpoint.
+
+        Args:
+            path: URL path pattern for the WebSocket endpoint
+
+        Returns:
+            A decorator that registers the WebSocket handler
+
+        Example:
+            @app.websocket("/ws")
+            async def websocket_endpoint(websocket):
+                await websocket.accept()
+                data = await websocket.receive_text()
+                await websocket.send_text(f"Echo: {data}")
+                await websocket.close()
+
+            @app.websocket("/ws/{room_id}")
+            async def room_endpoint(websocket, room_id: str):
+                await websocket.accept()
+                await websocket.send_text(f"Welcome to {room_id}")
+                await websocket.close()
+        """
+
+        def decorator(func: Callable):
+            self.add_websocket_route(path, func)
+            return func
+
+        return decorator
+    
+    def add_websocket_route(self, path: str, endpoint_func: Callable):
+        """
+        Register a WebSocket route with the application.
+
+        Args:
+            path: URL path pattern (supports path parameters)
+            endpoint_func: The async WebSocket handler function
+        """
+
+        async def websocket_handler(websocket: WebSocket):
+            # Extract path parameters
+            path_params = websocket.path_params
+
+            # Build kwargs for the handler
+            kwargs = {"websocket": websocket}
+
+            # Inject path parameters if the handler accepts them
+            sig = inspect.signature(endpoint_func)
+            for param in sig.parameters.values():
+                if param.name != "websocket" and param.name in path_params:
+                    kwargs[param.name] = path_params[param.name]
+
+            await endpoint_func(**kwargs)
+
+        route = WebSocketRoute(path, endpoint=websocket_handler)
+        self._router.routes.append(route)

tachyon_api/di.py

@@ -0,0 +1,86 @@
+"""
+Tachyon Web Framework - Dependency Injection Module
+
+This module provides a lightweight dependency injection system that supports
+both explicit and implicit dependency resolution with singleton pattern.
+"""
+
+from typing import Set, Type, TypeVar, Callable, Optional, Any
+
+# Global registry of injectable classes
+_registry: Set[Type] = set()
+
+T = TypeVar("T")
+
+
+class Depends:
+    """
+    Marker class for explicit dependency injection.
+
+    Use this as a default parameter value to explicitly mark a parameter
+    as a dependency that should be resolved and injected automatically.
+
+    Supports two modes:
+    1. Type-based: Depends() - resolves the dependency based on type annotation
+    2. Callable-based: Depends(callable) - calls the function to get the value
+
+    Example (type-based):
+        @app.get("/users")
+        def get_users(service: UserService = Depends()):
+            return service.list_all()
+
+    Example (callable-based):
+        def get_db():
+            return DatabaseConnection()
+
+        @app.get("/items")
+        def get_items(db = Depends(get_db)):
+            return db.query("SELECT * FROM items")
+
+    Example (async callable):
+        async def get_current_user():
+            return await fetch_user_from_token()
+
+        @app.get("/profile")
+        async def profile(user = Depends(get_current_user)):
+            return {"name": user.name}
+    """
+
+    def __init__(self, dependency: Optional[Callable[..., Any]] = None):
+        """
+        Initialize a dependency marker.
+
+        Args:
+            dependency: Optional callable (function, lambda, class) that will be
+                       called to produce the dependency value. If None, the
+                       dependency is resolved based on the parameter's type annotation.
+        """
+        self.dependency = dependency
+
+
+def injectable(cls: Type[T]) -> Type[T]:
+    """
+    Decorator to mark a class as injectable for dependency injection.
+
+    Classes marked with this decorator can be automatically resolved and
+    injected into endpoint functions and other injectable classes.
+
+    Args:
+        cls: The class to mark as injectable
+
+    Returns:
+        The same class, now registered for dependency injection
+
+    Example:
+        @injectable
+        class UserRepository:
+            def __init__(self, db: Database):
+                self.db = db
+
+        @injectable
+        class UserService:
+            def __init__(self, repo: UserRepository):
+                self.repo = repo
+    """
+    _registry.add(cls)
+    return cls

tachyon_api/exceptions.py

@@ -0,0 +1,39 @@
+"""
+Tachyon Exceptions Module
+
+Provides HTTP exception classes for clean error handling in endpoints.
+"""
+
+from typing import Any, Dict, Optional
+
+
+class HTTPException(Exception):
+    """
+    HTTP exception that can be raised in endpoints to return HTTP error responses.
+
+    Similar to FastAPI's HTTPException, this allows endpoints to abort request
+    processing and return a specific HTTP status code with a detail message.
+
+    Attributes:
+        status_code: The HTTP status code for the response
+        detail: A human-readable error message
+        headers: Optional dictionary of headers to include in the response
+
+    Example:
+        @app.get("/items/{item_id}")
+        def get_item(item_id: int):
+            if item_id not in items:
+                raise HTTPException(status_code=404, detail="Item not found")
+            return items[item_id]
+    """
+
+    def __init__(
+        self,
+        status_code: int,
+        detail: Any = None,
+        headers: Optional[Dict[str, str]] = None,
+    ) -> None:
+        self.status_code = status_code
+        self.detail = detail
+        self.headers = headers
+        super().__init__(detail)

tachyon_api/files.py

@@ -0,0 +1,14 @@
+"""
+Tachyon Web Framework - File Upload Module
+
+This module provides classes for handling file uploads in a FastAPI-compatible way.
+It wraps Starlette's file handling functionality.
+"""
+
+from starlette.datastructures import UploadFile as StarletteUploadFile
+
+# Re-export Starlette's UploadFile for use in Tachyon
+# This provides a familiar API for users coming from FastAPI
+UploadFile = StarletteUploadFile
+
+__all__ = ["UploadFile"]

tachyon_api/middlewares/__init__.py

@@ -0,0 +1,4 @@
+from .cors import CORSMiddleware
+from .logger import LoggerMiddleware
+
+__all__ = ["CORSMiddleware", "LoggerMiddleware"]