tachyon-api 0.9.0__py3-none-any.whl

tachyon_api/cli/commands/lint.py

@@ -0,0 +1,186 @@
+"""
+tachyon lint - Code quality tools (ruff wrapper)
+"""
+
+import typer
+import subprocess
+import shutil
+from pathlib import Path
+from typing import Optional, List
+
+app = typer.Typer(no_args_is_help=True)
+
+
+def _check_ruff_installed() -> bool:
+    """Check if ruff is installed."""
+    return shutil.which("ruff") is not None
+
+
+def _run_ruff(args: List[str], check: bool = True) -> int:
+    """Run ruff with given arguments."""
+    if not _check_ruff_installed():
+        typer.secho(
+            "❌ ruff is not installed. Install it with: pip install ruff",
+            fg=typer.colors.RED,
+        )
+        raise typer.Exit(1)
+
+    cmd = ["ruff"] + args
+    result = subprocess.run(cmd)
+    return result.returncode
+
+
+@app.command()
+def check(
+    path: Optional[Path] = typer.Argument(
+        None, help="Path to check (default: current directory)"
+    ),
+    fix: bool = typer.Option(
+        False, "--fix", "-f", help="Automatically fix issues where possible"
+    ),
+    watch: bool = typer.Option(
+        False, "--watch", "-w", help="Watch for changes and re-run"
+    ),
+):
+    """
+    🔍 Check code for linting issues.
+
+    Example:
+        tachyon lint check
+        tachyon lint check --fix
+        tachyon lint check ./src --watch
+    """
+    target = str(path) if path else "."
+
+    args = ["check", target]
+
+    if fix:
+        args.append("--fix")
+
+    if watch:
+        args.append("--watch")
+
+    typer.echo(f"🔍 Checking: {target}\n")
+    exit_code = _run_ruff(args)
+
+    if exit_code == 0:
+        typer.secho("\n✅ No issues found!", fg=typer.colors.GREEN)
+
+    raise typer.Exit(exit_code)
+
+
+@app.command()
+def fix(
+    path: Optional[Path] = typer.Argument(
+        None, help="Path to fix (default: current directory)"
+    ),
+    unsafe: bool = typer.Option(False, "--unsafe", help="Apply unsafe fixes as well"),
+):
+    """
+    🔧 Automatically fix linting issues.
+
+    Example:
+        tachyon lint fix
+        tachyon lint fix ./src
+        tachyon lint fix --unsafe
+    """
+    target = str(path) if path else "."
+
+    args = ["check", target, "--fix"]
+
+    if unsafe:
+        args.append("--unsafe-fixes")
+
+    typer.echo(f"🔧 Fixing: {target}\n")
+    exit_code = _run_ruff(args)
+
+    if exit_code == 0:
+        typer.secho("\n✅ All fixable issues resolved!", fg=typer.colors.GREEN)
+
+    raise typer.Exit(exit_code)
+
+
+@app.command()
+def format(
+    path: Optional[Path] = typer.Argument(
+        None, help="Path to format (default: current directory)"
+    ),
+    check_only: bool = typer.Option(
+        False, "--check", help="Check formatting without making changes"
+    ),
+    diff: bool = typer.Option(False, "--diff", help="Show diff of formatting changes"),
+):
+    """
+    🎨 Format code using ruff formatter.
+
+    Example:
+        tachyon lint format
+        tachyon lint format --check
+        tachyon lint format --diff
+    """
+    target = str(path) if path else "."
+
+    args = ["format", target]
+
+    if check_only:
+        args.append("--check")
+
+    if diff:
+        args.append("--diff")
+
+    typer.echo(f"🎨 Formatting: {target}\n")
+    exit_code = _run_ruff(args)
+
+    if exit_code == 0 and not check_only:
+        typer.secho("\n✅ Formatting complete!", fg=typer.colors.GREEN)
+    elif exit_code == 0 and check_only:
+        typer.secho("\n✅ Code is properly formatted!", fg=typer.colors.GREEN)
+
+    raise typer.Exit(exit_code)
+
+
+@app.command()
+def all(
+    path: Optional[Path] = typer.Argument(
+        None, help="Path to check and format (default: current directory)"
+    ),
+    fix: bool = typer.Option(True, "--fix/--no-fix", help="Auto-fix issues"),
+):
+    """
+    🚀 Run all quality checks: lint + format.
+
+    Example:
+        tachyon lint all
+        tachyon lint all --no-fix
+    """
+    target = str(path) if path else "."
+
+    typer.echo(f"🚀 Running all quality checks on: {target}\n")
+
+    # Run linting
+    typer.echo("─" * 40)
+    typer.echo("🔍 Step 1: Linting")
+    typer.echo("─" * 40)
+
+    lint_args = ["check", target]
+    if fix:
+        lint_args.append("--fix")
+
+    lint_code = _run_ruff(lint_args)
+
+    # Run formatting
+    typer.echo("\n" + "─" * 40)
+    typer.echo("🎨 Step 2: Formatting")
+    typer.echo("─" * 40)
+
+    format_args = ["format", target]
+    format_code = _run_ruff(format_args)
+
+    # Summary
+    typer.echo("\n" + "═" * 40)
+    if lint_code == 0 and format_code == 0:
+        typer.secho("✅ All checks passed!", fg=typer.colors.GREEN, bold=True)
+    else:
+        typer.secho("⚠️  Some issues found", fg=typer.colors.YELLOW, bold=True)
+
+    raise typer.Exit(max(lint_code, format_code))

tachyon_api/cli/commands/new.py

@@ -0,0 +1,82 @@
+"""
+tachyon new - Create new project with clean architecture
+"""
+
+import typer
+from pathlib import Path
+from typing import Optional
+
+from ..templates import ProjectTemplates
+
+
+def create_project(name: str, parent_path: Optional[Path] = None):
+    """
+    Create a new Tachyon project with clean architecture structure.
+
+    Structure:
+        my-api/
+        ├── app.py
+        ├── config.py
+        ├── requirements.txt
+        ├── modules/
+        │   └── __init__.py
+        ├── shared/
+        │   ├── __init__.py
+        │   ├── exceptions.py
+        │   └── dependencies.py
+        └── tests/
+            ├── __init__.py
+            └── conftest.py
+    """
+    # Determine project path
+    base_path = parent_path or Path.cwd()
+    project_path = base_path / name
+
+    # Check if already exists
+    if project_path.exists():
+        typer.secho(f"❌ Directory '{name}' already exists!", fg=typer.colors.RED)
+        raise typer.Exit(1)
+
+    typer.echo(f"\n🚀 Creating Tachyon project: {typer.style(name, bold=True)}\n")
+
+    # Create directory structure
+    directories = [
+        project_path,
+        project_path / "modules",
+        project_path / "shared",
+        project_path / "tests",
+    ]
+
+    for directory in directories:
+        directory.mkdir(parents=True, exist_ok=True)
+        typer.echo(f"  📁 Created {directory.relative_to(base_path)}/")
+
+    # Create files
+    files = {
+        "app.py": ProjectTemplates.APP,
+        "config.py": ProjectTemplates.CONFIG,
+        "requirements.txt": ProjectTemplates.REQUIREMENTS,
+        "modules/__init__.py": ProjectTemplates.MODULES_INIT,
+        "shared/__init__.py": ProjectTemplates.SHARED_INIT,
+        "shared/exceptions.py": ProjectTemplates.SHARED_EXCEPTIONS,
+        "shared/dependencies.py": ProjectTemplates.SHARED_DEPENDENCIES,
+        "tests/__init__.py": "",
+        "tests/conftest.py": ProjectTemplates.TESTS_CONFTEST,
+    }
+
+    for file_path, content in files.items():
+        full_path = project_path / file_path
+        full_path.write_text(content)
+        typer.echo(f"  📄 Created {file_path}")
+
+    # Success message
+    typer.echo(
+        f"\n✅ Project {typer.style(name, bold=True, fg=typer.colors.GREEN)} created successfully!"
+    )
+    typer.echo("\n📖 Next steps:")
+    typer.echo(f"   cd {name}")
+    typer.echo("   pip install -r requirements.txt")
+    typer.echo("   python app.py")
+    typer.echo("\n   Then generate your first service:")
+    typer.echo("   tachyon g service users")
+    typer.echo()

tachyon_api/cli/commands/openapi.py

@@ -0,0 +1,128 @@
+"""
+tachyon openapi - OpenAPI schema utilities
+"""
+
+import typer
+import json
+import importlib
+from pathlib import Path
+from typing import Optional
+
+app = typer.Typer(no_args_is_help=True)
+
+
+def _load_app(app_path: str):
+    """
+    Load a Tachyon app from module:attribute format.
+
+    Example: "app:app" or "main:application"
+    """
+    try:
+        module_path, attr_name = app_path.split(":")
+    except ValueError:
+        typer.secho(
+            "❌ Invalid app path format. Use 'module:attribute' (e.g., 'app:app')",
+            fg=typer.colors.RED,
+        )
+        raise typer.Exit(1)
+
+    try:
+        module = importlib.import_module(module_path)
+        app_instance = getattr(module, attr_name)
+        return app_instance
+    except ModuleNotFoundError as e:
+        typer.secho(f"❌ Module not found: {module_path}", fg=typer.colors.RED)
+        typer.secho(f"   Error: {e}", fg=typer.colors.YELLOW)
+        raise typer.Exit(1)
+    except AttributeError:
+        typer.secho(
+            f"❌ Attribute '{attr_name}' not found in module '{module_path}'",
+            fg=typer.colors.RED,
+        )
+        raise typer.Exit(1)
+
+
+@app.command()
+def export(
+    app_path: str = typer.Argument(
+        ..., help="App path in format 'module:attribute' (e.g., 'app:app')"
+    ),
+    output: Optional[Path] = typer.Option(
+        None, "--output", "-o", help="Output file path (default: stdout)"
+    ),
+    indent: int = typer.Option(2, "--indent", "-i", help="JSON indentation level"),
+):
+    """
+    📄 Export OpenAPI schema to JSON.
+
+    Example:
+        tachyon openapi export app:app
+        tachyon openapi export app:app -o openapi.json
+        tachyon openapi export app:app | jq .
+    """
+    # Add current directory to path for imports
+    import sys
+
+    sys.path.insert(0, str(Path.cwd()))
+
+    typer.echo(f"📄 Loading app from: {app_path}", err=True)
+
+    app_instance = _load_app(app_path)
+
+    # Get OpenAPI schema
+    try:
+        schema = app_instance.openapi_generator.get_openapi_schema()
+    except AttributeError:
+        typer.secho(
+            "❌ The loaded object doesn't appear to be a Tachyon app",
+            fg=typer.colors.RED,
+        )
+        raise typer.Exit(1)
+
+    # Convert to JSON
+    json_output = json.dumps(schema, indent=indent, ensure_ascii=False)
+
+    if output:
+        output.write_text(json_output)
+        typer.echo(f"✅ Schema exported to: {output}", err=True)
+    else:
+        typer.echo(json_output)
+
+
+@app.command()
+def validate(
+    schema_path: Path = typer.Argument(..., help="Path to OpenAPI schema file"),
+):
+    """
+    ✅ Validate an OpenAPI schema file.
+
+    Example:
+        tachyon openapi validate openapi.json
+    """
+    if not schema_path.exists():
+        typer.secho(f"❌ File not found: {schema_path}", fg=typer.colors.RED)
+        raise typer.Exit(1)
+
+    try:
+        content = schema_path.read_text()
+        schema = json.loads(content)
+
+        # Basic validation
+        required_fields = ["openapi", "info", "paths"]
+        missing = [f for f in required_fields if f not in schema]
+
+        if missing:
+            typer.secho(
+                f"❌ Invalid schema: missing required fields: {missing}",
+                fg=typer.colors.RED,
+            )
+            raise typer.Exit(1)
+
+        typer.secho("✅ Schema is valid!", fg=typer.colors.GREEN)
+        typer.echo(f"   OpenAPI version: {schema.get('openapi')}")
+        typer.echo(f"   Title: {schema.get('info', {}).get('title')}")
+        typer.echo(f"   Paths: {len(schema.get('paths', {}))}")
+
+    except json.JSONDecodeError as e:
+        typer.secho(f"❌ Invalid JSON: {e}", fg=typer.colors.RED)
+        raise typer.Exit(1)

tachyon_api/cli/main.py

@@ -0,0 +1,69 @@
+"""
+Tachyon CLI - Main entry point
+
+Commands:
+- tachyon new <project>     Create new project
+- tachyon generate          Generate components (alias: g)
+- tachyon openapi           OpenAPI utilities
+- tachyon lint              Code quality (ruff wrapper)
+"""
+
+import typer
+from typing import Optional
+from pathlib import Path
+
+from .commands import generate, openapi, lint
+
+app = typer.Typer(
+    name="tachyon",
+    help="🚀 Tachyon CLI - Fast API development toolkit",
+    add_completion=False,
+    no_args_is_help=True,
+)
+
+# Register sub-commands
+app.add_typer(
+    generate.app,
+    name="generate",
+    help="Generate components (service, controller, etc.)",
+)
+app.add_typer(generate.app, name="g", help="Alias for 'generate'", hidden=True)
+app.add_typer(openapi.app, name="openapi", help="OpenAPI schema utilities")
+app.add_typer(lint.app, name="lint", help="Code quality tools (ruff wrapper)")
+
+
+@app.command()
+def new(
+    name: str = typer.Argument(..., help="Project name"),
+    path: Optional[Path] = typer.Option(
+        None,
+        "--path",
+        "-p",
+        help="Parent directory for the project (default: current directory)",
+    ),
+):
+    """
+    🏗️  Create a new Tachyon project with clean architecture.
+
+    Example:
+        tachyon new my-api
+        tachyon new my-api --path ./projects
+    """
+    from .commands.new import create_project
+
+    create_project(name, path)
+
+
+@app.command()
+def version():
+    """Show Tachyon version."""
+    typer.echo("Tachyon API v0.6.6")
+
+
+def main():
+    """Entry point for the CLI."""
+    app()
+
+
+if __name__ == "__main__":
+    main()

tachyon_api/cli/templates/__init__.py

@@ -0,0 +1,8 @@
+"""
+CLI Templates for code generation.
+"""
+
+from .project import ProjectTemplates
+from .service import ServiceTemplates
+
+__all__ = ["ProjectTemplates", "ServiceTemplates"]

tachyon_api/cli/templates/project.py

@@ -0,0 +1,194 @@
+"""
+Project scaffolding templates.
+"""
+
+
+class ProjectTemplates:
+    """Templates for `tachyon new` command."""
+
+    APP = '''"""
+Main application entry point.
+"""
+
+import uvicorn
+from tachyon_api import Tachyon
+from config import settings
+
+# Initialize app
+app = Tachyon()
+
+
+@app.get("/")
+def root():
+    """Health check endpoint."""
+    return {"status": "ok", "app": settings.APP_NAME}
+
+
+@app.get("/health")
+def health():
+    """Detailed health check."""
+    return {
+        "status": "healthy",
+        "version": settings.VERSION,
+    }
+
+
+# Import and register routers here
+# from modules.users import router as users_router
+# app.include_router(users_router)
+
+
+if __name__ == "__main__":
+    uvicorn.run(
+        "app:app",
+        host=settings.HOST,
+        port=settings.PORT,
+        reload=settings.DEBUG,
+    )
+'''
+
+    CONFIG = '''"""
+Application configuration.
+"""
+
+import os
+
+
+class Settings:
+    """Application settings loaded from environment variables."""
+    
+    APP_NAME: str = os.getenv("APP_NAME", "Tachyon API")
+    VERSION: str = os.getenv("VERSION", "0.1.0")
+    DEBUG: bool = os.getenv("DEBUG", "true").lower() == "true"
+    
+    # Server
+    HOST: str = os.getenv("HOST", "0.0.0.0")
+    PORT: int = int(os.getenv("PORT", "8000"))
+    
+    # Database (example)
+    # DATABASE_URL: str = os.getenv("DATABASE_URL", "sqlite:///./app.db")
+
+
+settings = Settings()
+'''
+
+    REQUIREMENTS = """# Tachyon API Framework
+tachyon-api>=0.6.0
+
+# Server
+uvicorn[standard]>=0.30.0
+
+# Development
+pytest>=8.0.0
+pytest-asyncio>=0.23.0
+httpx>=0.27.0
+ruff>=0.4.0
+"""
+
+    MODULES_INIT = '''"""
+Application modules.
+
+Each module follows clean architecture:
+- controller: HTTP endpoints (router)
+- service: Business logic
+- repository: Data access
+- dto: Data transfer objects
+"""
+'''
+
+    SHARED_INIT = '''"""
+Shared utilities and dependencies.
+"""
+
+from .exceptions import *
+from .dependencies import *
+'''
+
+    SHARED_EXCEPTIONS = '''"""
+Custom application exceptions.
+"""
+
+from tachyon_api import HTTPException
+
+
+class NotFoundError(HTTPException):
+    """Resource not found."""
+    
+    def __init__(self, resource: str, id: str):
+        super().__init__(
+            status_code=404,
+            detail=f"{resource} with id '{id}' not found"
+        )
+
+
+class UnauthorizedError(HTTPException):
+    """Authentication required."""
+    
+    def __init__(self, detail: str = "Not authenticated"):
+        super().__init__(
+            status_code=401,
+            detail=detail,
+            headers={"WWW-Authenticate": "Bearer"}
+        )
+
+
+class ForbiddenError(HTTPException):
+    """Access denied."""
+    
+    def __init__(self, detail: str = "Access denied"):
+        super().__init__(status_code=403, detail=detail)
+
+
+class BadRequestError(HTTPException):
+    """Invalid request."""
+    
+    def __init__(self, detail: str):
+        super().__init__(status_code=400, detail=detail)
+
+
+class ConflictError(HTTPException):
+    """Resource conflict (e.g., duplicate)."""
+    
+    def __init__(self, detail: str):
+        super().__init__(status_code=409, detail=detail)
+'''
+
+    SHARED_DEPENDENCIES = '''"""
+Shared dependencies for dependency injection.
+"""
+
+from tachyon_api import Depends
+from tachyon_api.security import OAuth2PasswordBearer
+
+# Example: OAuth2 token dependency
+# oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/auth/token")
+# 
+# async def get_current_user(token: str = Depends(oauth2_scheme)):
+#     # Validate token and return user
+#     pass
+'''
+
+    TESTS_CONFTEST = '''"""
+Pytest configuration and fixtures.
+"""
+
+import pytest
+from httpx import AsyncClient, ASGITransport
+
+
+@pytest.fixture
+def app():
+    """Create test application instance."""
+    from app import app
+    return app
+
+
+@pytest.fixture
+async def client(app):
+    """Create async test client."""
+    async with AsyncClient(
+        transport=ASGITransport(app=app),
+        base_url="http://test"
+    ) as client:
+        yield client
+'''