snapstack 1.0.0__py3-none-any.whl

pysnap/templates/fastapi/README.md.j2

@@ -0,0 +1,57 @@
+# {{ project_name }}
+
+> Generated with [pysnap](https://github.com/yourusername/pysnap)
+
+## Stack
+
+- **Framework:** FastAPI
+- **Database:** {{ database | capitalize }}
+- **Package Manager:** {{ package_manager }}
+{%- if include_auth %}
+- **Auth:** JWT
+{%- endif %}
+{%- if include_docker %}
+- **Docker:** Yes
+{%- endif %}
+{%- if include_ci %}
+- **CI/CD:** GitHub Actions
+{%- endif %}
+
+## Getting Started
+
+```bash
+{%- if package_manager == "uv" %}
+uv sync
+uv run uvicorn app.main:app --reload
+{%- elif package_manager == "poetry" %}
+poetry install
+poetry run uvicorn app.main:app --reload
+{%- else %}
+pip install -e ".[dev]"
+uvicorn app.main:app --reload
+{%- endif %}
+```
+
+Visit:
+- **Docs:** http://localhost:8000/docs
+- **Health:** http://localhost:8000/api/v1/health
+{%- if include_tests %}
+
+## Tests
+
+```bash
+{%- if package_manager == "uv" %}
+uv run pytest tests/ -v
+{%- else %}
+pytest tests/ -v
+{%- endif %}
+```
+{%- endif %}
+{%- if include_docker %}
+
+## Docker
+
+```bash
+docker compose up --build
+```
+{%- endif %}

pysnap/templates/fastapi/api/routes/auth.py.j2

@@ -0,0 +1,18 @@
+from fastapi import APIRouter, HTTPException, status
+from app.schemas.user import UserCreate, Token
+from app.core.security import get_password_hash, create_access_token
+
+router = APIRouter()
+
+
+@router.post("/auth/register", status_code=status.HTTP_201_CREATED)
+async def register(user_in: UserCreate):
+    hashed_password = get_password_hash(user_in.password)
+    # TODO: persist user to database
+    return {"message": "User created", "email": user_in.email}
+
+
+@router.post("/auth/login", response_model=Token)
+async def login(email: str, password: str):
+    # TODO: look up user from database
+    raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid credentials")

pysnap/templates/fastapi/api/routes/health.py.j2

@@ -0,0 +1,8 @@
+from fastapi import APIRouter
+
+router = APIRouter()
+
+
+@router.get("/health", summary="Health check")
+async def health_check():
+    return {"status": "ok", "version": "0.1.0"}

pysnap/templates/fastapi/app/__init__.py.j2

@@ -0,0 +1 @@
+

pysnap/templates/fastapi/core/config.py.j2

@@ -0,0 +1,26 @@
+from pydantic_settings import BaseSettings
+from typing import List
+
+
+class Settings(BaseSettings):
+    PROJECT_NAME: str = "{{ project_name }}"
+    VERSION: str = "0.1.0"
+    DESCRIPTION: str = "Generated by pysnap"
+    API_PREFIX: str = "/api/v1"
+    DEBUG: bool = False
+    ALLOWED_ORIGINS: List[str] = ["http://localhost:3000", "http://localhost:8000"]
+{%- if database == "postgresql" %}
+    DATABASE_URL: str = "postgresql+asyncpg://user:password@localhost:5432/{{ project_name_slug }}"
+{%- elif database == "sqlite" %}
+    DATABASE_URL: str = "sqlite+aiosqlite:///./{{ project_name_slug }}.db"
+{%- endif %}
+{%- if include_auth %}
+    SECRET_KEY: str = "change-this-secret-key-in-production"
+    ACCESS_TOKEN_EXPIRE_MINUTES: int = 30
+    ALGORITHM: str = "HS256"
+{%- endif %}
+
+    model_config = {"env_file": ".env", "case_sensitive": True}
+
+
+settings = Settings()

pysnap/templates/fastapi/core/security.py.j2

@@ -0,0 +1,22 @@
+from datetime import datetime, timedelta, timezone
+from typing import Optional
+from jose import jwt
+from passlib.context import CryptContext
+from app.core.config import settings
+
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+
+
+def verify_password(plain: str, hashed: str) -> bool:
+    return pwd_context.verify(plain, hashed)
+
+
+def get_password_hash(password: str) -> str:
+    return pwd_context.hash(password)
+
+
+def create_access_token(data: dict, expires_delta: Optional[timedelta] = None) -> str:
+    to_encode = data.copy()
+    expire = datetime.now(timezone.utc) + (expires_delta or timedelta(minutes=settings.ACCESS_TOKEN_EXPIRE_MINUTES))
+    to_encode["exp"] = expire
+    return jwt.encode(to_encode, settings.SECRET_KEY, algorithm=settings.ALGORITHM)

pysnap/templates/fastapi/db/base.py.j2

@@ -0,0 +1,5 @@
+from sqlalchemy.orm import DeclarativeBase
+
+
+class Base(DeclarativeBase):
+    pass

pysnap/templates/fastapi/db/session.py.j2

@@ -0,0 +1,15 @@
+from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine, async_sessionmaker
+from app.core.config import settings
+
+engine = create_async_engine(settings.DATABASE_URL, echo=settings.DEBUG)
+AsyncSessionLocal = async_sessionmaker(engine, class_=AsyncSession, expire_on_commit=False)
+
+
+async def get_db() -> AsyncSession:
+    async with AsyncSessionLocal() as session:
+        try:
+            yield session
+            await session.commit()
+        except Exception:
+            await session.rollback()
+            raise

pysnap/templates/fastapi/docker-compose.yml.j2

@@ -0,0 +1,30 @@
+services:
+  api:
+    build: .
+    ports:
+      - "8000:8000"
+    env_file: .env
+{%- if database == "postgresql" %}
+    depends_on:
+      db:
+        condition: service_healthy
+
+  db:
+    image: postgres:16-alpine
+    environment:
+      POSTGRES_USER: user
+      POSTGRES_PASSWORD: password
+      POSTGRES_DB: {{ project_name_slug }}
+    ports:
+      - "5432:5432"
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U user -d {{ project_name_slug }}"]
+      interval: 5s
+      timeout: 5s
+      retries: 5
+
+volumes:
+  postgres_data:
+{%- endif %}

pysnap/templates/fastapi/main.py.j2

@@ -0,0 +1,27 @@
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from app.core.config import settings
+from app.api.routes import health
+{% if include_auth %}
+from app.api.routes import auth
+{% endif %}
+
+app = FastAPI(
+    title=settings.PROJECT_NAME,
+    version=settings.VERSION,
+    description=settings.DESCRIPTION,
+    openapi_url=f"{settings.API_PREFIX}/openapi.json",
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=settings.ALLOWED_ORIGINS,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+app.include_router(health.router, prefix=settings.API_PREFIX, tags=["health"])
+{% if include_auth %}
+app.include_router(auth.router, prefix=settings.API_PREFIX, tags=["auth"])
+{% endif %}

pysnap/templates/fastapi/models/user.py.j2

@@ -0,0 +1,13 @@
+from sqlalchemy import String, Boolean
+from sqlalchemy.orm import Mapped, mapped_column
+from app.db.base import Base
+
+
+class User(Base):
+    __tablename__ = "users"
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    email: Mapped[str] = mapped_column(String(255), unique=True, index=True)
+    hashed_password: Mapped[str] = mapped_column(String(255))
+    is_active: Mapped[bool] = mapped_column(Boolean, default=True)
+    is_superuser: Mapped[bool] = mapped_column(Boolean, default=False)

pysnap/templates/fastapi/pyproject.toml.j2

@@ -0,0 +1,48 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "{{ project_name }}"
+version = "0.1.0"
+description = "Generated by pysnap"
+requires-python = ">=3.11"
+dependencies = [
+    "fastapi>=0.115.0",
+    "uvicorn[standard]>=0.32.0",
+    "pydantic>=2.0.0",
+    "pydantic-settings>=2.0.0",
+{%- if database == "sqlite" %}
+    "sqlalchemy>=2.0.0",
+    "aiosqlite>=0.20.0",
+{%- elif database == "postgresql" %}
+    "sqlalchemy>=2.0.0",
+    "asyncpg>=0.30.0",
+    "alembic>=1.13.0",
+{%- endif %}
+{%- if include_auth %}
+    "python-jose[cryptography]>=3.3.0",
+    "passlib[bcrypt]>=1.7.4",
+    "email-validator>=2.0.0",
+{%- endif %}
+]
+
+[project.optional-dependencies]
+dev = [
+{%- if include_tests %}
+    "pytest>=8.0.0",
+    "pytest-asyncio>=0.24.0",
+    "httpx>=0.27.0",
+{%- endif %}
+    "ruff>=0.8.0",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["app"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+
+[tool.ruff]
+line-length = 100
+target-version = "py311"

pysnap/templates/fastapi/schemas/user.py.j2

@@ -0,0 +1,18 @@
+from pydantic import BaseModel, EmailStr
+
+
+class UserCreate(BaseModel):
+    email: EmailStr
+    password: str
+
+
+class UserOut(BaseModel):
+    id: int
+    email: EmailStr
+    is_active: bool
+    model_config = {"from_attributes": True}
+
+
+class Token(BaseModel):
+    access_token: str
+    token_type: str = "bearer"

pysnap/templates/fastapi/template.json

@@ -0,0 +1,53 @@
+{
+  "name": "fastapi",
+  "display_name": "FastAPI",
+  "description": "Async FastAPI project with Pydantic v2, SQLAlchemy 2, and uvicorn",
+  "version": "1.0.0",
+  "files": {
+    "always": {
+      "app/__init__.py.j2": "app/__init__.py",
+      "main.py.j2": "app/main.py",
+      "core/__init__.py.j2": "app/core/__init__.py",
+      "core/config.py.j2": "app/core/config.py",
+      "api/__init__.py.j2": "app/api/__init__.py",
+      "api/routes/__init__.py.j2": "app/api/routes/__init__.py",
+      "api/routes/health.py.j2": "app/api/routes/health.py",
+      "models/__init__.py.j2": "app/models/__init__.py",
+      "schemas/__init__.py.j2": "app/schemas/__init__.py",
+      "pyproject.toml.j2": "pyproject.toml",
+      ".env.example.j2": ".env.example",
+      ".gitignore.j2": ".gitignore",
+      "README.md.j2": "README.md"
+    },
+    "when_database": {
+      "db/__init__.py.j2": "app/db/__init__.py",
+      "db/base.py.j2": "app/db/base.py",
+      "db/session.py.j2": "app/db/session.py"
+    },
+    "when_auth": {
+      "core/security.py.j2": "app/core/security.py",
+      "api/routes/auth.py.j2": "app/api/routes/auth.py",
+      "schemas/user.py.j2": "app/schemas/user.py"
+    },
+    "when_auth_and_database": {
+      "models/user.py.j2": "app/models/user.py"
+    },
+    "when_docker": {
+      "Dockerfile.j2": "Dockerfile",
+      "docker-compose.yml.j2": "docker-compose.yml",
+      ".dockerignore.j2": ".dockerignore"
+    },
+    "when_tests": {
+      "tests/__init__.py.j2": "tests/__init__.py",
+      "tests/conftest.py.j2": "tests/conftest.py",
+      "tests/test_health.py.j2": "tests/test_health.py"
+    },
+    "when_ci": {
+      ".github/workflows/ci.yml.j2": ".github/workflows/ci.yml"
+    }
+  },
+  "prompts": [],
+  "hooks": {
+    "post_generate": []
+  }
+}

pysnap/templates/fastapi/tests/conftest.py.j2

@@ -0,0 +1,9 @@
+import pytest
+from httpx import AsyncClient, ASGITransport
+from app.main import app
+
+
+@pytest.fixture
+async def client():
+    async with AsyncClient(transport=ASGITransport(app=app), base_url="http://test") as ac:
+        yield ac

pysnap/templates/fastapi/tests/test_health.py.j2

@@ -0,0 +1,9 @@
+import pytest
+from httpx import AsyncClient
+
+
+@pytest.mark.asyncio
+async def test_health_check(client: AsyncClient):
+    response = await client.get("/api/v1/health")
+    assert response.status_code == 200
+    assert response.json()["status"] == "ok"

pysnap/templates/flask/.dockerignore.j2

@@ -0,0 +1,14 @@
+__pycache__/
+*.py[cod]
+.venv/
+venv/
+.env
+dist/
+*.egg-info/
+.pytest_cache/
+.coverage
+htmlcov/
+*.log
+.DS_Store
+Thumbs.db
+.git/

pysnap/templates/flask/.github/workflows/ci.yml.j2

@@ -0,0 +1,34 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  lint-and-test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+{% if package_manager == "uv" %}
+      - name: Install uv
+        run: pip install uv
+      - name: Install dependencies
+        run: uv sync
+      - name: Lint
+        run: uv run ruff check .
+      - name: Test
+        run: uv run pytest
+{% else %}
+      - name: Install dependencies
+        run: pip install -e ".[dev]"
+      - name: Lint
+        run: ruff check .
+      - name: Test
+        run: pytest
+{% endif %}

pysnap/templates/flask/.gitignore.j2

@@ -0,0 +1,13 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+.env
+.venv/
+venv/
+dist/
+build/
+*.db
+.pytest_cache/
+.ruff_cache/
+htmlcov/
+.coverage

pysnap/templates/flask/Dockerfile.j2

@@ -0,0 +1,14 @@
+FROM python:3.11-slim
+WORKDIR /app
+{% if package_manager == "uv" -%}
+COPY --from=ghcr.io/astral-sh/uv:latest /uv /bin/uv
+COPY pyproject.toml uv.lock* ./
+RUN uv sync --frozen --no-dev
+COPY . .
+CMD ["uv", "run", "flask", "--app", "wsgi", "run", "--host=0.0.0.0"]
+{%- else -%}
+COPY pyproject.toml ./
+RUN pip install --no-cache-dir -e .
+COPY . .
+CMD ["flask", "--app", "wsgi", "run", "--host=0.0.0.0"]
+{%- endif %}

pysnap/templates/flask/README.md.j2

@@ -0,0 +1,34 @@
+# {{ project_name }}
+
+A Flask project generated by [pysnap](https://github.com/pysnap-dev/pysnap).
+
+## Quick Start
+
+```bash
+{% if package_manager == "uv" %}
+uv sync
+uv run flask --app wsgi run --debug
+{% else %}
+pip install -e ".[dev]"
+flask --app wsgi run --debug
+{% endif %}
+```
+
+{% if include_docker %}
+## Docker
+
+```bash
+docker compose up
+```
+{% endif %}
+{% if include_tests %}
+## Tests
+
+```bash
+{% if package_manager == "uv" %}
+uv run pytest
+{% else %}
+pytest
+{% endif %}
+```
+{% endif %}

pysnap/templates/flask/app/__init__.py.j2

@@ -0,0 +1,30 @@
+"""Flask application factory for {{ project_name }}."""
+
+from flask import Flask
+
+from app.config import Config
+from app.extensions import db
+
+
+def create_app(config_class=Config) -> Flask:
+    """Create and configure the Flask application."""
+    app = Flask(__name__)
+    app.config.from_object(config_class)
+
+    # Initialize extensions
+{% if database != "none" %}
+    db.init_app(app)
+{% endif %}
+
+    # Register blueprints
+    from app.routes.health import health_bp
+
+    app.register_blueprint(health_bp)
+
+{% if include_auth %}
+    from app.routes.auth import auth_bp
+
+    app.register_blueprint(auth_bp, url_prefix="/api/auth")
+{% endif %}
+
+    return app

pysnap/templates/flask/app/config.py.j2

@@ -0,0 +1,23 @@
+"""Flask app configuration."""
+
+import os
+from pathlib import Path
+
+
+class Config:
+    """Base configuration."""
+
+    SECRET_KEY: str = os.environ.get("SECRET_KEY", "insecure-dev-key-change-in-production")
+    DEBUG: bool = os.environ.get("DEBUG", "false").lower() == "true"
+{% if database == "postgresql" %}
+    SQLALCHEMY_DATABASE_URI: str = os.environ.get(
+        "DATABASE_URL", "postgresql+psycopg://user:password@localhost/{{ project_name_slug }}"
+    )
+{% elif database == "sqlite" %}
+    SQLALCHEMY_DATABASE_URI: str = os.environ.get(
+        "DATABASE_URL", f"sqlite:///{Path(__file__).parent.parent}/{{ project_name_slug }}.db"
+    )
+{% else %}
+    SQLALCHEMY_DATABASE_URI: str = ""
+{% endif %}
+    SQLALCHEMY_TRACK_MODIFICATIONS: bool = False

pysnap/templates/flask/app/extensions.py.j2

@@ -0,0 +1,9 @@
+"""Flask extensions -- initialized here, bound to app in create_app()."""
+
+{% if database != "none" %}
+from flask_sqlalchemy import SQLAlchemy
+
+db = SQLAlchemy()
+{% else %}
+# No database extensions configured
+{% endif %}

pysnap/templates/flask/app/models/__init__.py.j2

@@ -0,0 +1 @@
+"""Models package."""

pysnap/templates/flask/app/models/user.py.j2

@@ -0,0 +1,16 @@
+from app.extensions import db
+
+
+class User(db.Model):
+    """User model."""
+
+    __tablename__ = "users"
+
+    id = db.Column(db.Integer, primary_key=True)
+    email = db.Column(db.String(255), unique=True, nullable=False)
+    username = db.Column(db.String(100), unique=True, nullable=False)
+    password_hash = db.Column(db.String(255), nullable=False)
+    created_at = db.Column(db.DateTime, server_default=db.func.now())
+
+    def __repr__(self) -> str:
+        return f"<User {self.email}>"

pysnap/templates/flask/app/routes/__init__.py.j2

@@ -0,0 +1 @@
+"""Routes package."""

pysnap/templates/flask/app/routes/auth.py.j2

@@ -0,0 +1,31 @@
+"""Auth blueprint."""
+
+from flask import Blueprint, jsonify, request
+from flask_jwt_extended import create_access_token, create_refresh_token, jwt_required, get_jwt_identity
+
+auth_bp = Blueprint("auth", __name__)
+
+
+@auth_bp.post("/login")
+def login():
+    """Obtain a JWT token pair."""
+    data = request.get_json(silent=True) or {}
+    username = data.get("username")
+    password = data.get("password")
+
+    # TODO: Replace with real user lookup + password verification
+    if not username or not password:
+        return jsonify({"error": "username and password required"}), 400
+
+    access_token = create_access_token(identity=username)
+    refresh_token = create_refresh_token(identity=username)
+    return jsonify(access_token=access_token, refresh_token=refresh_token), 200
+
+
+@auth_bp.post("/refresh")
+@jwt_required(refresh=True)
+def refresh():
+    """Refresh an access token using a refresh token."""
+    identity = get_jwt_identity()
+    access_token = create_access_token(identity=identity)
+    return jsonify(access_token=access_token), 200

pysnap/templates/flask/app/routes/health.py.j2

@@ -0,0 +1,11 @@
+"""Health check blueprint."""
+
+from flask import Blueprint, jsonify
+
+health_bp = Blueprint("health", __name__, url_prefix="/api")
+
+
+@health_bp.get("/health")
+def health():
+    """Health check endpoint."""
+    return jsonify({"status": "ok", "service": "{{ project_name }}"})