fastapi-fullstack 0.1.2__py3-none-any.whl

fastapi_gen/template/{{cookiecutter.project_slug}}/backend/.dockerignore

@@ -0,0 +1,60 @@
+{%- if cookiecutter.enable_docker %}
+# Git
+.git
+.gitignore
+
+# Python
+__pycache__
+*.py[cod]
+*$py.class
+*.so
+.Python
+.venv
+venv/
+ENV/
+
+# IDE
+.idea
+.vscode
+*.swp
+*.swo
+
+# Testing
+.pytest_cache
+.coverage
+htmlcov/
+.tox
+.nox
+
+# Documentation
+docs/_build/
+*.md
+!README.md
+
+# Build artifacts
+dist/
+build/
+*.egg-info/
+
+# Development files
+.env
+.env.local
+*.db
+*.sqlite
+
+# Docker
+Dockerfile*
+docker-compose*.yml
+.docker
+
+# CI/CD
+.github/
+.gitlab-ci.yml
+
+# Misc
+.DS_Store
+Thumbs.db
+*.log
+{%- else %}
+# Docker is disabled
+{%- endif %}

fastapi_gen/template/{{cookiecutter.project_slug}}/backend/.pre-commit-config.yaml

@@ -0,0 +1,32 @@
+{%- if cookiecutter.enable_precommit %}
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v5.0.0
+    hooks:
+      - id: trailing-whitespace
+      - id: end-of-file-fixer
+      - id: check-yaml
+      - id: check-toml
+      - id: check-added-large-files
+        args: ['--maxkb=1000']
+      - id: check-merge-conflict
+      - id: detect-private-key
+
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.8.0
+    hooks:
+      - id: ruff
+        args: [--fix]
+      - id: ruff-format
+
+  - repo: https://github.com/pre-commit/mirrors-mypy
+    rev: v1.13.0
+    hooks:
+      - id: mypy
+        additional_dependencies:
+          - pydantic>=2.0.0
+          - pydantic-settings>=2.0.0
+        args: [--ignore-missing-imports]
+{%- else %}
+# Pre-commit is disabled for this project
+{%- endif %}

fastapi_gen/template/{{cookiecutter.project_slug}}/backend/Dockerfile

@@ -0,0 +1,56 @@
+{%- if cookiecutter.enable_docker %}
+# Build stage
+FROM python:{{ cookiecutter.python_version }}-slim AS builder
+
+ENV PYTHONUNBUFFERED=1
+ENV PYTHONDONTWRITEBYTECODE=1
+WORKDIR /app
+
+# Install uv
+COPY --from=ghcr.io/astral-sh/uv:latest /uv /bin/uv
+ENV UV_COMPILE_BYTECODE=1
+ENV UV_LINK_MODE=copy
+
+# Install dependencies
+RUN --mount=type=cache,target=/root/.cache/uv \
+    --mount=type=bind,source=uv.lock,target=uv.lock \
+    --mount=type=bind,source=pyproject.toml,target=pyproject.toml \
+    uv sync --frozen --no-install-project --no-dev
+
+# Copy application
+COPY . /app
+
+# Install project
+RUN --mount=type=cache,target=/root/.cache/uv \
+    uv sync --frozen --no-dev
+
+
+# Runtime stage
+FROM python:{{ cookiecutter.python_version }}-slim
+
+ENV PYTHONUNBUFFERED=1
+ENV PYTHONDONTWRITEBYTECODE=1
+WORKDIR /app
+
+# Copy virtual environment from builder
+COPY --from=builder /app/.venv /app/.venv
+COPY --from=builder /app /app
+
+# Add venv to path
+ENV PATH="/app/.venv/bin:$PATH"
+
+# Create non-root user
+RUN adduser --disabled-password --gecos "" appuser && \
+    chown -R appuser:appuser /app
+USER appuser
+
+EXPOSE {{ cookiecutter.backend_port }}
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
+    CMD python -c "import httpx; httpx.get('http://localhost:{{ cookiecutter.backend_port }}/api/v1/health')" || exit 1
+
+CMD ["python", "-m", "cli.commands", "server", "run", "--host", "0.0.0.0", "--port", "{{ cookiecutter.backend_port }}"]
+{%- else %}
+# Docker is disabled for this project
+{%- endif %}

fastapi_gen/template/{{cookiecutter.project_slug}}/backend/alembic/env.py

@@ -0,0 +1,76 @@
+{%- if cookiecutter.use_postgresql or cookiecutter.use_sqlite %}
+"""Alembic migration environment."""
+# ruff: noqa: I001 - Imports structured for Jinja2 template conditionals
+
+from logging.config import fileConfig
+
+from alembic import context
+from sqlalchemy import engine_from_config, pool
+
+from app.core.config import settings
+from app.db.base import Base
+
+# Import all models here to ensure they are registered with Base.metadata
+{%- if cookiecutter.use_jwt %}
+from app.db.models.user import User  # noqa: F401
+{%- endif %}
+
+config = context.config
+
+if config.config_file_name is not None:
+    fileConfig(config.config_file_name)
+
+target_metadata = Base.metadata
+
+
+def get_url() -> str:
+    """Get database URL from settings."""
+{%- if cookiecutter.use_postgresql %}
+    return settings.DATABASE_URL_SYNC
+{%- else %}
+    return settings.DATABASE_URL
+{%- endif %}
+
+
+def run_migrations_offline() -> None:
+    """Run migrations in 'offline' mode."""
+    url = get_url()
+    context.configure(
+        url=url,
+        target_metadata=target_metadata,
+        literal_binds=True,
+        dialect_opts={"paramstyle": "named"},
+    )
+
+    with context.begin_transaction():
+        context.run_migrations()
+
+
+def run_migrations_online() -> None:
+    """Run migrations in 'online' mode."""
+    configuration = config.get_section(config.config_ini_section)
+    configuration["sqlalchemy.url"] = get_url()
+
+    connectable = engine_from_config(
+        configuration,
+        prefix="sqlalchemy.",
+        poolclass=pool.NullPool,
+    )
+
+    with connectable.connect() as connection:
+        context.configure(
+            connection=connection,
+            target_metadata=target_metadata,
+        )
+
+        with context.begin_transaction():
+            context.run_migrations()
+
+
+if context.is_offline_mode():
+    run_migrations_offline()
+else:
+    run_migrations_online()
+{%- else %}
+# Alembic - not configured (no SQL database)
+{%- endif %}

fastapi_gen/template/{{cookiecutter.project_slug}}/backend/alembic/script.py.mako

@@ -0,0 +1,30 @@
+{%- if cookiecutter.use_postgresql or cookiecutter.use_sqlite %}
+"""${message}
+
+Revision ID: ${up_revision}
+Revises: ${down_revision | comma,n}
+Create Date: ${create_date}
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+${imports if imports else ""}
+
+# revision identifiers, used by Alembic.
+revision: str = ${repr(up_revision)}
+down_revision: Union[str, None] = ${repr(down_revision)}
+branch_labels: Union[str, Sequence[str], None] = ${repr(branch_labels)}
+depends_on: Union[str, Sequence[str], None] = ${repr(depends_on)}
+
+
+def upgrade() -> None:
+    ${upgrades if upgrades else "pass"}
+
+
+def downgrade() -> None:
+    ${downgrades if downgrades else "pass"}
+{%- else %}
+# Alembic - not configured
+{%- endif %}

fastapi_gen/template/{{cookiecutter.project_slug}}/backend/alembic.ini

@@ -0,0 +1,48 @@
+{%- if cookiecutter.use_postgresql or cookiecutter.use_sqlite %}
+# Alembic Configuration
+
+[alembic]
+script_location = alembic
+prepend_sys_path = .
+version_path_separator = os
+# Human-readable migration file names: 2024-01-15_add_users_table.py
+file_template = %%(year)d-%%(month).2d-%%(day).2d_%%(slug)s
+
+[post_write_hooks]
+
+[loggers]
+keys = root,sqlalchemy,alembic
+
+[handlers]
+keys = console
+
+[formatters]
+keys = generic
+
+[logger_root]
+level = WARN
+handlers = console
+qualname =
+
+[logger_sqlalchemy]
+level = WARN
+handlers =
+qualname = sqlalchemy.engine
+
+[logger_alembic]
+level = INFO
+handlers =
+qualname = alembic
+
+[handler_console]
+class = StreamHandler
+args = (sys.stderr,)
+level = NOTSET
+formatter = generic
+
+[formatter_generic]
+format = %(levelname)-5.5s [%(name)s] %(message)s
+datefmt = %H:%M:%S
+{%- else %}
+# Alembic - not configured (no SQL database)
+{%- endif %}

fastapi_gen/template/{{cookiecutter.project_slug}}/backend/app/__init__.py

@@ -0,0 +1,3 @@
+"""{{ cookiecutter.project_description }}"""
+
+__version__ = "0.1.0"

fastapi_gen/template/{{cookiecutter.project_slug}}/backend/app/admin.py

@@ -0,0 +1,115 @@
+{%- if cookiecutter.enable_admin_panel and cookiecutter.use_postgresql %}
+"""SQLAdmin configuration."""
+
+from typing import ClassVar
+
+from sqlalchemy import create_engine
+from sqladmin import Admin, ModelView
+{%- if cookiecutter.admin_require_auth %}
+from sqladmin.authentication import AuthenticationBackend
+from starlette.requests import Request
+{%- endif %}
+
+from app.core.config import settings
+from app.db.models.user import User
+{%- if cookiecutter.admin_require_auth %}
+from app.core.security import verify_password
+{%- endif %}
+
+# SQLAdmin requires a synchronous engine
+sync_engine = create_engine(settings.DATABASE_URL_SYNC, echo=settings.DEBUG)
+
+{%- if cookiecutter.admin_require_auth %}
+
+
+class AdminAuth(AuthenticationBackend):
+    """Admin panel authentication backend.
+
+    Requires superuser credentials to access the admin panel.
+    """
+
+    async def login(self, request: Request) -> bool:
+        """Validate admin login credentials."""
+        form = await request.form()
+        email = form.get("username")
+        password = form.get("password")
+
+        if not email or not password:
+            return False
+
+        # Get user from database
+        from sqlalchemy.orm import Session
+        with Session(sync_engine) as session:
+            user = session.query(User).filter(User.email == email).first()
+
+            if (
+                user
+                and verify_password(str(password), user.hashed_password)
+                and user.is_superuser
+            ):
+                # Store user info in session
+                request.session["admin_user_id"] = str(user.id)
+                request.session["admin_email"] = user.email
+                return True
+
+        return False
+
+    async def logout(self, request: Request) -> bool:
+        """Clear admin session."""
+        request.session.clear()
+        return True
+
+    async def authenticate(self, request: Request) -> bool:
+        """Check if user is authenticated."""
+        admin_user_id = request.session.get("admin_user_id")
+        if not admin_user_id:
+            return False
+
+        # Verify user still exists and is superuser
+        from sqlalchemy.orm import Session
+        with Session(sync_engine) as session:
+            user = session.query(User).filter(User.id == admin_user_id).first()
+            if user and user.is_superuser and user.is_active:
+                return True
+
+        # User no longer valid, clear session
+        request.session.clear()
+        return False
+{%- endif %}
+
+
+class UserAdmin(ModelView, model=User):  # type: ignore[call-arg]
+    """User admin view."""
+
+    column_list: ClassVar = [User.id, User.email, User.is_active, User.is_superuser, User.created_at]
+    column_searchable_list: ClassVar = [User.email, User.full_name]
+    column_sortable_list: ClassVar = [User.id, User.email, User.is_active, User.created_at]
+    form_excluded_columns: ClassVar = [User.hashed_password, User.created_at, User.updated_at]
+    can_create: ClassVar = True
+    can_edit: ClassVar = True
+    can_delete: ClassVar = True
+    can_view_details: ClassVar = True
+
+
+def setup_admin(app):
+    """Setup SQLAdmin for the FastAPI app."""
+    {%- if cookiecutter.admin_require_auth %}
+    authentication_backend = AdminAuth(secret_key=settings.SECRET_KEY)
+    admin = Admin(
+        app,
+        sync_engine,
+        title="{{ cookiecutter.project_name }} Admin",
+        authentication_backend=authentication_backend,
+    )
+    {%- else %}
+    admin = Admin(
+        app,
+        sync_engine,
+        title="{{ cookiecutter.project_name }} Admin",
+    )
+    {%- endif %}
+    admin.add_view(UserAdmin)
+    return admin
+{%- else %}
+"""Admin panel - not configured."""
+{%- endif %}

fastapi_gen/template/{{cookiecutter.project_slug}}/backend/app/agents/__init__.py

@@ -0,0 +1,13 @@
+{%- if cookiecutter.enable_ai_agent %}
+"""AI Agents module using PydanticAI.
+
+This module contains agents that handle AI-powered interactions.
+Tools are defined in the tools/ subdirectory.
+"""
+
+from app.agents.assistant import AssistantAgent, Deps
+
+__all__ = ["AssistantAgent", "Deps"]
+{%- else %}
+"""AI Agents - not configured."""
+{%- endif %}

fastapi_gen/template/{{cookiecutter.project_slug}}/backend/app/agents/assistant.py

@@ -0,0 +1,202 @@
+{%- if cookiecutter.enable_ai_agent %}
+"""Assistant agent with PydanticAI.
+
+The main conversational agent that can be extended with custom tools.
+"""
+
+import logging
+from dataclasses import dataclass, field
+from typing import Any
+
+from pydantic_ai import Agent, RunContext
+from pydantic_ai.messages import (
+    ModelRequest,
+    ModelResponse,
+    SystemPromptPart,
+    TextPart,
+    UserPromptPart,
+)
+from pydantic_ai.models.openai import OpenAIChatModel
+from pydantic_ai.providers.openai import OpenAIProvider
+from pydantic_ai.settings import ModelSettings
+
+from app.agents.tools import get_current_datetime
+from app.core.config import settings
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class Deps:
+    """Dependencies for the assistant agent.
+
+    These are passed to tools via RunContext.
+    """
+
+    user_id: str | None = None
+    user_name: str | None = None
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+
+class AssistantAgent:
+    """Assistant agent wrapper for conversational AI.
+
+    Encapsulates agent creation and execution with tool support.
+    """
+
+    def __init__(
+        self,
+        model_name: str | None = None,
+        temperature: float | None = None,
+        system_prompt: str = "You are a helpful assistant.",
+    ):
+        self.model_name = model_name or settings.AI_MODEL
+        self.temperature = temperature or settings.AI_TEMPERATURE
+        self.system_prompt = system_prompt
+        self._agent: Agent[Deps, str] | None = None
+
+    def _create_agent(self) -> Agent[Deps, str]:
+        """Create and configure the PydanticAI agent."""
+        model = OpenAIChatModel(
+            self.model_name,
+            provider=OpenAIProvider(api_key=settings.OPENAI_API_KEY),
+        )
+
+        agent = Agent[Deps, str](
+            model=model,
+            model_settings=ModelSettings(temperature=self.temperature),
+            system_prompt=self.system_prompt,
+        )
+
+        self._register_tools(agent)
+
+        return agent
+
+    def _register_tools(self, agent: Agent[Deps, str]) -> None:
+        """Register all tools on the agent."""
+
+        @agent.tool
+        async def current_datetime(ctx: RunContext[Deps]) -> str:
+            """Get the current date and time.
+
+            Use this tool when you need to know the current date or time.
+            """
+            return get_current_datetime()
+
+    @property
+    def agent(self) -> Agent[Deps, str]:
+        """Get or create the agent instance."""
+        if self._agent is None:
+            self._agent = self._create_agent()
+        return self._agent
+
+    async def run(
+        self,
+        user_input: str,
+        history: list[dict[str, str]] | None = None,
+        deps: Deps | None = None,
+    ) -> tuple[str, list[Any], Deps]:
+        """Run agent and return the output along with tool call events.
+
+        Args:
+            user_input: User's message.
+            history: Conversation history as list of {"role": "...", "content": "..."}.
+            deps: Optional dependencies. If not provided, a new Deps will be created.
+
+        Returns:
+            Tuple of (output_text, tool_events, deps).
+        """
+        model_history: list[ModelRequest | ModelResponse] = []
+
+        for msg in history or []:
+            if msg["role"] == "user":
+                model_history.append(ModelRequest(parts=[UserPromptPart(content=msg["content"])]))
+            elif msg["role"] == "assistant":
+                model_history.append(ModelResponse(parts=[TextPart(content=msg["content"])]))
+            elif msg["role"] == "system":
+                model_history.append(ModelRequest(parts=[SystemPromptPart(content=msg["content"])]))
+
+        agent_deps = deps if deps is not None else Deps()
+
+        logger.info(f"Running agent with user input: {user_input[:100]}...")
+        result = await self.agent.run(user_input, deps=agent_deps, message_history=model_history)
+
+        tool_events: list[Any] = []
+        for message in result.all_messages():
+            if hasattr(message, "parts"):
+                for part in message.parts:
+                    if hasattr(part, "tool_name"):
+                        tool_events.append(part)
+
+        logger.info(f"Agent run complete. Output length: {len(result.output)} chars")
+
+        return result.output, tool_events, agent_deps
+
+    async def iter(
+        self,
+        user_input: str,
+        history: list[dict[str, str]] | None = None,
+        deps: Deps | None = None,
+    ):
+        """Stream agent execution with full event access.
+
+        Args:
+            user_input: User's message.
+            history: Conversation history.
+            deps: Optional dependencies.
+
+        Yields:
+            Agent events for streaming responses.
+        """
+        model_history: list[ModelRequest | ModelResponse] = []
+
+        for msg in history or []:
+            if msg["role"] == "user":
+                model_history.append(ModelRequest(parts=[UserPromptPart(content=msg["content"])]))
+            elif msg["role"] == "assistant":
+                model_history.append(ModelResponse(parts=[TextPart(content=msg["content"])]))
+            elif msg["role"] == "system":
+                model_history.append(ModelRequest(parts=[SystemPromptPart(content=msg["content"])]))
+
+        agent_deps = deps if deps is not None else Deps()
+
+        async with self.agent.iter(
+            user_input,
+            deps=agent_deps,
+            message_history=model_history,
+        ) as run:
+            async for event in run:
+                yield event
+
+
+def get_agent() -> AssistantAgent:
+    """Factory function to create an AssistantAgent.
+
+    Returns:
+        Configured AssistantAgent instance.
+    """
+    return AssistantAgent()
+
+
+async def run_agent(
+    user_input: str,
+    history: list[dict[str, str]],
+    deps: Deps | None = None,
+) -> tuple[str, list[Any], Deps]:
+    """Run agent and return the output along with tool call events.
+
+    This is a convenience function for backwards compatibility.
+
+    Args:
+        user_input: User's message.
+        history: Conversation history.
+        deps: Optional dependencies.
+
+    Returns:
+        Tuple of (output_text, tool_events, deps).
+    """
+    agent = get_agent()
+    return await agent.run(user_input, history, deps)
+{%- else %}
+"""Assistant agent - not configured."""
+{%- endif %}

fastapi_gen/template/{{cookiecutter.project_slug}}/backend/app/agents/tools/__init__.py

@@ -0,0 +1,13 @@
+{%- if cookiecutter.enable_ai_agent %}
+"""Agent tools module.
+
+This module contains utility functions that can be used as agent tools.
+Tools are registered in the agent definition using @agent.tool decorator.
+"""
+
+from app.agents.tools.datetime_tool import get_current_datetime
+
+__all__ = ["get_current_datetime"]
+{%- else %}
+"""Agent tools - not configured."""
+{%- endif %}

fastapi_gen/template/{{cookiecutter.project_slug}}/backend/app/agents/tools/datetime_tool.py

@@ -0,0 +1,17 @@
+{%- if cookiecutter.enable_ai_agent %}
+"""Date and time utilities for agents."""
+
+from datetime import datetime
+
+
+def get_current_datetime() -> str:
+    """Get the current date and time.
+
+    Returns:
+        A string with the current date and time.
+    """
+    now = datetime.now()
+    return f"Current date: {now.strftime('%Y-%m-%d')}, Current time: {now.strftime('%H:%M:%S')}"
+{%- else %}
+"""Datetime tools - not configured."""
+{%- endif %}

fastapi_gen/template/{{cookiecutter.project_slug}}/backend/app/api/__init__.py

@@ -0,0 +1 @@
+"""API module."""