forgeapi 0.1.0__py3-none-any.whl

fastapi_forge/templates/base/app/main.py.jinja

@@ -0,0 +1,24 @@
+"""
+Application Entry Point
+
+This module provides the main entry point for running the application.
+"""
+
+import uvicorn
+
+from app.core.config import get_config
+
+
+def main():
+    """Run the application with uvicorn."""
+    config = get_config()
+    uvicorn.run(
+        config.app.uvicorn,
+        host=config.app.host,
+        port=config.app.port,
+        reload=config.app.reload,
+    )
+
+
+if __name__ == "__main__":
+    main()

fastapi_forge/templates/base/app/models/__init__.py.jinja

@@ -0,0 +1,7 @@
+"""
+SQLAlchemy Models Module
+"""
+
+from app.models.base import Base
+
+__all__ = ["Base"]

fastapi_forge/templates/base/app/models/base.py.jinja

@@ -0,0 +1,13 @@
+"""
+Base Model
+
+This module defines the SQLAlchemy declarative base for all models.
+"""
+
+from sqlalchemy.orm import DeclarativeBase
+
+
+class Base(DeclarativeBase):
+    """SQLAlchemy declarative base class."""
+
+    pass

fastapi_forge/templates/base/app/schemas/__init__.py.jinja

@@ -0,0 +1,3 @@
+"""
+Pydantic Schemas Module
+"""

fastapi_forge/templates/base/app/schemas/api_schema.py.jinja

@@ -0,0 +1,20 @@
+"""
+API Schemas
+
+This module defines common API response schemas.
+"""
+
+from pydantic import BaseModel, Field
+
+
+class MessageResponse(BaseModel):
+    """Generic message response schema."""
+
+    message: str = Field(..., description="Response message")
+
+
+class HealthResponse(BaseModel):
+    """Health check response schema."""
+
+    status: str = Field(..., description="Health status")
+    version: str = Field(..., description="Application version")

fastapi_forge/templates/base/app/schemas/auth_schema.py.jinja

@@ -0,0 +1,21 @@
+"""
+Authentication Schemas
+
+This module defines Pydantic schemas for authentication.
+"""
+
+from pydantic import BaseModel, Field
+
+
+class TokenResponse(BaseModel):
+    """JWT token response schema."""
+
+    access_token: str = Field(..., description="JWT access token")
+    token_type: str = Field(default="bearer", description="Token type")
+
+
+class LoginRequest(BaseModel):
+    """Login request schema."""
+
+    email: str = Field(..., description="User email")
+    password: str = Field(..., description="User password")

fastapi_forge/templates/base/app/server.py.jinja

@@ -0,0 +1,99 @@
+"""
+FastAPI Application Server
+
+This module configures and creates the FastAPI application instance.
+"""
+
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI
+
+from app.api.health_api import healthAPI
+{% if use_auth %}
+from app.api.auth_api import authAPI
+{% endif %}
+from app.core.config import get_config
+{% if use_database %}
+from app.core.database import DatabaseUtil
+{% endif %}
+{% if use_redis %}
+from app.core.redis import RedisUtil
+{% endif %}
+from app.exceptions.handler import register_exception_handlers
+from app.utils.log import log
+
+config = get_config()
+
+
+async def init_services(app: FastAPI):
+    """
+    Initialize application services.
+
+    Args:
+        app: FastAPI application instance
+    """
+    app.state.config = config
+{% if use_database %}
+    app.state.db_engine = await DatabaseUtil.init_engine(config.db)
+{% endif %}
+{% if use_redis %}
+    app.state.redis = await RedisUtil.init_redis(config.redis)
+{% endif %}
+
+
+async def close_services(app: FastAPI):
+    """
+    Close application services.
+
+    Args:
+        app: FastAPI application instance
+    """
+{% if use_database %}
+    await DatabaseUtil.close_engine(app.state.db_engine)
+{% endif %}
+{% if use_redis %}
+    await RedisUtil.close_redis(app.state.redis)
+{% endif %}
+    pass
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """
+    Application lifespan manager.
+
+    Args:
+        app: FastAPI application instance
+    """
+    # Startup
+    await init_services(app)
+    log.info(f"{config.app.name} started successfully")
+
+    yield
+
+    # Shutdown
+    await close_services(app)
+    log.info(f"{config.app.name} shutdown complete")
+
+
+# Create FastAPI application
+app = FastAPI(
+    title=config.app.name,
+    description=config.app.description,
+    version=config.app.version,
+    lifespan=lifespan,
+)
+
+# Register exception handlers
+register_exception_handlers(app)
+
+# Register routers
+API_ROUTES = [
+    {"router": healthAPI, "tags": ["Health"]},
+{% if use_auth %}
+    {"router": authAPI, "tags": ["Authentication"]},
+{% endif %}
+]
+
+for route in API_ROUTES:
+    app.include_router(router=route["router"], tags=route["tags"])

fastapi_forge/templates/base/app/services/__init__.py.jinja

@@ -0,0 +1,3 @@
+"""
+Services Module
+"""

fastapi_forge/templates/base/app/utils/__init__.py.jinja

@@ -0,0 +1,3 @@
+"""
+Utilities Module
+"""

fastapi_forge/templates/base/app/utils/log.py.jinja

@@ -0,0 +1,21 @@
+"""
+Logging Utilities
+
+This module provides logging configuration and utilities.
+"""
+
+import logging
+import sys
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(levelname)s - %(message)s",
+    datefmt="%Y-%m-%d %H:%M:%S",
+    handlers=[
+        logging.StreamHandler(sys.stdout),
+    ],
+)
+
+# Create logger instance
+log = logging.getLogger("{{ project_slug }}")

fastapi_forge/templates/base/config.yaml.jinja

@@ -0,0 +1,71 @@
+env: dev
+
+# Development environment
+dev:
+  app:
+    name: {{ project_name }} (dev)
+    description: {{ project_description }}
+    api: /api
+    host: 0.0.0.0
+    port: 8000
+    uvicorn: app.server:app
+    version: 0.1.0
+    reload: true
+
+{% if use_database %}
+  db:
+{% if use_postgres %}
+    host: localhost
+    port: 5432
+    user: postgres
+    password: postgres
+    database: {{ project_slug }}
+    driver_name: postgresql+asyncpg
+{% elif use_mysql %}
+    host: localhost
+    port: 3306
+    user: root
+    password: root
+    database: {{ project_slug }}
+    driver_name: mysql+aiomysql
+{% elif use_sqlite %}
+    host: ""
+    port: 0
+    user: ""
+    password: ""
+    database: {{ project_slug }}.db
+    driver_name: sqlite+aiosqlite
+{% endif %}
+    echo: true
+    pool_size: 5
+    max_overflow: 10
+    pool_recycle: 3600
+    pool_timeout: 30
+{% endif %}
+
+{% if use_redis %}
+  redis:
+    host: localhost
+    port: 6379
+    db: 0
+    password: ""
+{% endif %}
+
+{% if use_auth %}
+  jwt:
+    secret_key: your-secret-key-change-in-production
+    algorithm: HS256
+    expire_minutes: 1440
+{% endif %}
+
+# Production environment
+prod:
+  app:
+    name: {{ project_name }}
+    reload: false
+
+{% if use_database %}
+  db:
+    echo: false
+    pool_size: 20
+{% endif %}

fastapi_forge/templates/base/docker-compose.yml.jinja

@@ -0,0 +1,117 @@
+services:
+  app:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    ports:
+      - "8000:8000"
+    environment:
+      - PYTHONPATH=/app
+{% if use_database or use_redis %}
+    depends_on:
+{% if "postgres" in docker_services %}
+      - postgres
+{% endif %}
+{% if "mysql" in docker_services %}
+      - mysql
+{% endif %}
+{% if "redis" in docker_services %}
+      - redis
+{% endif %}
+{% endif %}
+    volumes:
+      - .:/app
+    command: python -m app.main
+{% if use_database or use_redis %}
+    networks:
+      - app-network
+{% endif %}
+
+{% if "postgres" in docker_services %}
+  postgres:
+    image: postgres:16-alpine
+    environment:
+      POSTGRES_USER: postgres
+      POSTGRES_PASSWORD: postgres
+      POSTGRES_DB: {{ project_slug }}
+    ports:
+      - "5432:5432"
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+    networks:
+      - app-network
+{% endif %}
+
+{% if "mysql" in docker_services %}
+  mysql:
+    image: mysql:8
+    environment:
+      MYSQL_ROOT_PASSWORD: root
+      MYSQL_DATABASE: {{ project_slug }}
+    ports:
+      - "3306:3306"
+    volumes:
+      - mysql_data:/var/lib/mysql
+    networks:
+      - app-network
+{% endif %}
+
+{% if "redis" in docker_services %}
+  redis:
+    image: redis:alpine
+    ports:
+      - "6379:6379"
+    networks:
+      - app-network
+{% endif %}
+
+{% if "rabbitmq" in docker_services %}
+  rabbitmq:
+    image: rabbitmq:3-management
+    ports:
+      - "5672:5672"
+      - "15672:15672"
+    environment:
+      RABBITMQ_DEFAULT_USER: admin
+      RABBITMQ_DEFAULT_PASS: admin
+    volumes:
+      - rabbitmq_data:/var/lib/rabbitmq
+    networks:
+      - app-network
+{% endif %}
+
+{% if "minio" in docker_services %}
+  minio:
+    image: minio/minio
+    command: server /data --console-address ":9001"
+    ports:
+      - "9000:9000"
+      - "9001:9001"
+    environment:
+      MINIO_ROOT_USER: minioadmin
+      MINIO_ROOT_PASSWORD: minioadmin
+    volumes:
+      - minio_data:/data
+    networks:
+      - app-network
+{% endif %}
+
+{% if use_database or use_redis %}
+volumes:
+{% if "postgres" in docker_services %}
+  postgres_data:
+{% endif %}
+{% if "mysql" in docker_services %}
+  mysql_data:
+{% endif %}
+{% if "rabbitmq" in docker_services %}
+  rabbitmq_data:
+{% endif %}
+{% if "minio" in docker_services %}
+  minio_data:
+{% endif %}
+
+networks:
+  app-network:
+    driver: bridge
+{% endif %}

fastapi_forge/templates/base/pyproject.toml.jinja

@@ -0,0 +1,86 @@
+[project]
+name = "{{ project_slug }}"
+version = "0.1.0"
+description = "{{ project_description }}"
+authors = [
+    { name = "{{ author_name }}", email = "{{ author_email }}" }
+]
+readme = "README.md"
+requires-python = ">={{ python_version }}"
+
+dependencies = [
+    "fastapi[standard]>=0.115.0",
+    "uvicorn>=0.34.0",
+    "pyyaml>=6.0.0",
+    "pydantic>=2.0.0",
+    "pydantic-settings>=2.0.0",
+{% if use_database %}
+    "sqlalchemy[asyncio]>=2.0.0",
+{% endif %}
+{% if use_postgres %}
+    "asyncpg>=0.29.0",
+    "psycopg[binary]>=3.2.0",
+{% elif use_mysql %}
+    "aiomysql>=0.2.0",
+{% elif use_sqlite %}
+    "aiosqlite>=0.20.0",
+{% endif %}
+{% if use_alembic %}
+    "alembic>=1.15.0",
+{% endif %}
+{% if use_redis %}
+    "redis>=5.2.0",
+{% endif %}
+{% if use_auth %}
+    "pyjwt>=2.10.0",
+    "passlib[bcrypt]>=1.7.4",
+    "bcrypt==4.0.1",
+{% endif %}
+]
+
+[dependency-groups]
+dev = [
+    "pytest>=8.3.0",
+    "pytest-asyncio>=0.26.0",
+{% if use_ruff %}
+    "ruff>=0.11.0",
+{% endif %}
+{% if use_redis %}
+    "fakeredis>=2.27.0",
+{% endif %}
+{% if use_postgres %}
+    "pytest-postgresql>=4.1.0",
+{% endif %}
+]
+
+[project.scripts]
+start = "app.main:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["app"]
+{% if use_ruff %}
+
+[tool.ruff]
+line-length = 88
+indent-width = 4
+target-version = "py{{ python_version | replace('.', '') }}"
+
+[tool.ruff.lint]
+select = ["E", "W", "F", "I", "B", "C4", "UP"]
+ignore = ["E501"]
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"
+{% endif %}
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+python_functions = ["test_*"]
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"

fastapi_forge/templates/base/pytest.ini.jinja

@@ -0,0 +1,10 @@
+[pytest]
+testpaths = tests
+python_files = test_*.py
+python_classes = Test*
+python_functions = test_*
+asyncio_mode = auto
+addopts = -v --tb=short
+filterwarnings =
+    ignore::DeprecationWarning
+    ignore::PendingDeprecationWarning

fastapi_forge/templates/base/ruff.toml.jinja

@@ -0,0 +1,33 @@
+# Ruff Configuration
+# https://docs.astral.sh/ruff/
+
+line-length = 120
+target-version = "py310"
+
+[lint]
+select = [
+    "E",      # pycodestyle errors
+    "W",      # pycodestyle warnings
+    "F",      # pyflakes
+    "I",      # isort
+    "B",      # flake8-bugbear
+    "C4",     # flake8-comprehensions
+    "UP",     # pyupgrade
+    "ARG",    # flake8-unused-arguments
+    "SIM",    # flake8-simplify
+]
+ignore = [
+    "E501",   # line too long (handled by formatter)
+    "B008",   # do not perform function calls in argument defaults
+    "B904",   # raise without from inside except
+    "ARG001", # unused function argument
+]
+
+[lint.isort]
+known-first-party = ["app"]
+force-single-line = false
+lines-after-imports = 2
+
+[lint.per-file-ignores]
+"tests/*" = ["ARG001", "S101"]
+"alembic/*" = ["ARG001"]

fastapi_forge/templates/base/tests/__init__.py.jinja

@@ -0,0 +1,3 @@
+"""
+Test Suite
+"""

fastapi_forge/templates/base/tests/conftest.py.jinja

@@ -0,0 +1,31 @@
+"""
+Pytest Configuration and Fixtures
+
+This module provides test fixtures and configuration for pytest.
+"""
+
+import pytest
+from fastapi.testclient import TestClient
+{% if use_redis %}
+import fakeredis.aioredis
+{% endif %}
+
+from app.server import app
+
+
+@pytest.fixture
+def client():
+    """Create a test client for the FastAPI application."""
+    with TestClient(app) as test_client:
+        yield test_client
+
+
+{% if use_redis %}
+@pytest.fixture
+async def fake_redis():
+    """Create a fake Redis instance for testing."""
+    fake_redis = fakeredis.aioredis.FakeRedis(decode_responses=True)
+    yield fake_redis
+    await fake_redis.flushall()
+    await fake_redis.aclose()
+{% endif %}

fastapi_forge/templates/base/tests/test_health.py.jinja

@@ -0,0 +1,24 @@
+"""
+Health API Tests
+
+This module contains tests for the health check endpoints.
+"""
+
+
+def test_health_check(client):
+    """Test the health check endpoint returns healthy status."""
+    response = client.get("/api/health")
+    assert response.status_code == 200
+
+    data = response.json()
+    assert data["status"] == "healthy"
+    assert "version" in data
+
+
+def test_readiness_check(client):
+    """Test the readiness check endpoint returns ready status."""
+    response = client.get("/api/health/ready")
+    assert response.status_code == 200
+
+    data = response.json()
+    assert data["status"] == "ready"