inifastapi 0.1.0__tar.gz

inifastapi-0.1.0/.claude/settings.local.json

@@ -0,0 +1,7 @@
+{
+  "permissions": {
+    "allow": [
+      "mcp__tavily__tavily_search"
+    ]
+  }
+}

inifastapi-0.1.0/.gitignore

@@ -0,0 +1,21 @@
+
+coverage/
+.DS_Store
+*.log
+
+!.env.example
+playwright-report/
+test-results/
+.idea/
+
+.mypy_cache
+.pytest_cache
+.ruff_cache
+
+.venv
+__pycache__
+*.lock
+
+coverage.*
+.coverage
+.storage

inifastapi-0.1.0/.vscode/settings.json

@@ -0,0 +1,13 @@
+{
+  "python.defaultInterpreterPath": "${workspaceFolder}/.venv/bin/python",
+  "python.terminal.activateEnvironment": true,
+  "python.analysis.extraPaths": [
+    "${workspaceFolder}/src"
+  ],
+  "python.testing.pytestEnabled": true,
+  "python.testing.unittestEnabled": false,
+  "python.testing.cwd": "${workspaceFolder}",
+  "python.testing.pytestArgs": [
+    "tests"
+  ]
+}

inifastapi-0.1.0/AGENTS.md

@@ -0,0 +1,28 @@
+# Repository Guidelines
+
+## Project Structure & Module Organization
+Core package code lives in `src/inifastapi/`. `cli.py` exposes the Typer entrypoint, `scaffold.py` builds the output plan, `bootstrap.py` handles environment setup, and `options.py` defines normalized project settings. Template assets for generated projects live under `src/inifastapi/templates/` and are grouped by feature (`project/`, `database/`, `auth/`, `task_queue/`, `docker/`, `ci/`). Tests are in `tests/` and mirror the package surface with files such as `test_cli.py` and `test_scaffold.py`. `output/` is generated example output; treat it as a fixture, not primary source code.
+
+## Build, Test, and Development Commands
+Use Python `3.12.10` with `uv`.
+
+- `uv sync --group dev` installs runtime and development dependencies.
+- `uv run pytest` runs the full test suite.
+- `uv run pytest --cov=src/inifastapi --cov-report=term-missing` checks coverage against the enforced 100% threshold.
+- `uv run ruff check .` runs linting.
+- `uv run pyright` runs static type checking with `.venv` and `src` configured.
+- `uv run inifastapi init demo-service --no-bootstrap-env` exercises the CLI without creating a managed environment.
+
+## Coding Style & Naming Conventions
+Follow existing Python style: 4-space indentation, explicit type hints, and small focused functions. Use `snake_case` for modules, functions, variables, and tests. Use `PascalCase` for dataclasses such as `ProjectOptions`. Keep CLI flags and template paths descriptive and aligned with existing names like `--with-task-queue` and `templates/project/main.py.j2`. Prefer standard-library helpers before adding dependencies.
+
+## Testing Guidelines
+Tests use `pytest`, `typer.testing.CliRunner`, and coverage. New tests should be named `test_<behavior>.py` or `test_<behavior>` and should assert observable outcomes, especially generated file paths and CLI exit codes. Keep coverage at `100`; if you add a branch in `src/inifastapi/`, add a test for it in the same change.
+
+## Commit & Pull Request Guidelines
+This directory does not include `.git`, so no local commit history is available to infer conventions. Use short imperative commit subjects such as `Add GitLab CI template option`. Keep pull requests focused and include:
+
+- a brief summary of behavior changes
+- the commands you ran (`uv run pytest`, `uv run ruff check .`, `uv run pyright`)
+- sample CLI invocations when scaffold output changes
+- updated generated fixtures or templates when applicable

inifastapi-0.1.0/PKG-INFO

@@ -0,0 +1,85 @@
+Metadata-Version: 2.4
+Name: inifastapi
+Version: 0.1.0
+Summary: A reusable FastAPI project initializer with production-oriented templates.
+Author: Haoyue
+License: MIT
+Requires-Python: ==3.12.10
+Requires-Dist: jinja2>=3.1.6
+Requires-Dist: typer>=0.24.1
+Description-Content-Type: text/markdown
+
+# inifastapi
+
+`inifastapi` is a reusable FastAPI project initializer. It generates a production-oriented starter project with explicit router aggregation, settings, middleware, tests, and optional feature modules.
+
+## Requirements
+
+`uv` must be installed on the machine. The scaffold uses `uv` both to run the CLI and to bootstrap the generated FastAPI project.
+
+## Usage
+
+You do not need to install `inifastapi` first if it has been published. The recommended one-off command is:
+
+```bash
+uvx inifastapi init my-service
+```
+
+More examples:
+
+```bash
+uvx inifastapi init my-service --package-name app --with-database --with-auth
+uvx inifastapi init my-service --layout src --with-task-queue --with-ci --ci-provider github
+```
+
+## Published Package
+
+If `inifastapi` is available on PyPI, prefer `uvx` for one-off usage:
+
+```bash
+uvx inifastapi init my-service
+```
+
+This downloads and runs the scaffold temporarily. It does not add `inifastapi` to the generated project's dependencies.
+
+## Local Development
+
+If you are working from this repository before publishing, use the local environment:
+
+```bash
+uv sync --group dev
+uv run inifastapi init my-service
+```
+
+You can also run the local source tree without installing it globally:
+
+```bash
+uvx --from . inifastapi init my-service
+```
+
+## Install
+
+If you want a persistent local development environment for the scaffold itself:
+
+```bash
+uv sync --group dev
+```
+
+## Features
+
+- Explicit `APIRouter` aggregation
+- `pydantic-settings` configuration
+- `lifespan` startup/shutdown scaffolding
+- Request logging and security middleware
+- Optional PostgreSQL + SQLAlchemy + Alembic
+- Optional JWT auth skeleton
+- Optional Redis cache skeleton
+- Optional Celery + RabbitMQ skeleton
+- Optional Docker and CI templates
+- `uv`-managed `pyproject.toml`, `uv.lock`, and `.venv`
+
+## Development
+
+```bash
+uv run python -m pytest
+```

inifastapi-0.1.0/README.md

@@ -0,0 +1,74 @@
+# inifastapi
+
+`inifastapi` is a reusable FastAPI project initializer. It generates a production-oriented starter project with explicit router aggregation, settings, middleware, tests, and optional feature modules.
+
+## Requirements
+
+`uv` must be installed on the machine. The scaffold uses `uv` both to run the CLI and to bootstrap the generated FastAPI project.
+
+## Usage
+
+You do not need to install `inifastapi` first if it has been published. The recommended one-off command is:
+
+```bash
+uvx inifastapi init my-service
+```
+
+More examples:
+
+```bash
+uvx inifastapi init my-service --package-name app --with-database --with-auth
+uvx inifastapi init my-service --layout src --with-task-queue --with-ci --ci-provider github
+```
+
+## Published Package
+
+If `inifastapi` is available on PyPI, prefer `uvx` for one-off usage:
+
+```bash
+uvx inifastapi init my-service
+```
+
+This downloads and runs the scaffold temporarily. It does not add `inifastapi` to the generated project's dependencies.
+
+## Local Development
+
+If you are working from this repository before publishing, use the local environment:
+
+```bash
+uv sync --group dev
+uv run inifastapi init my-service
+```
+
+You can also run the local source tree without installing it globally:
+
+```bash
+uvx --from . inifastapi init my-service
+```
+
+## Install
+
+If you want a persistent local development environment for the scaffold itself:
+
+```bash
+uv sync --group dev
+```
+
+## Features
+
+- Explicit `APIRouter` aggregation
+- `pydantic-settings` configuration
+- `lifespan` startup/shutdown scaffolding
+- Request logging and security middleware
+- Optional PostgreSQL + SQLAlchemy + Alembic
+- Optional JWT auth skeleton
+- Optional Redis cache skeleton
+- Optional Celery + RabbitMQ skeleton
+- Optional Docker and CI templates
+- `uv`-managed `pyproject.toml`, `uv.lock`, and `.venv`
+
+## Development
+
+```bash
+uv run python -m pytest
+```

inifastapi-0.1.0/pypi-key.txt

@@ -0,0 +1 @@
+pypi-AgEIcHlwaS5vcmcCJDViMTcxMDUxLTA2M2MtNGYyMS1hYmNlLTZmYWFmZDY4YzE5ZQACKlszLCJhMDUwY2E5YS03ZjdmLTQ4NjUtOGZlYy1mMzczZTIwZjUyYzUiXQAABiANaxfHNgnAfiWdGjf97j26kI6sOqtKc23C-dW9ccXHKg

inifastapi-0.1.0/pyproject.toml

@@ -0,0 +1,52 @@
+[build-system]
+requires = ["hatchling>=1.25.0"]
+build-backend = "hatchling.build"
+
+[project]
+name = "inifastapi"
+version = "0.1.0"
+description = "A reusable FastAPI project initializer with production-oriented templates."
+readme = "README.md"
+requires-python = "==3.12.10"
+license = { text = "MIT" }
+authors = [
+  { name = "Haoyue" }
+]
+dependencies = [
+    "jinja2>=3.1.6",
+    "typer>=0.24.1",
+]
+
+[project.scripts]
+inifastapi = "inifastapi.cli:app"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/inifastapi"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.ruff]
+extend-exclude = ["output"]
+
+[tool.coverage.run]
+source = ["src/inifastapi"]
+omit = [
+    "src/inifastapi/templates/*",
+    "src/inifastapi/templates/**/*",
+]
+
+[tool.coverage.report]
+fail_under = 100
+show_missing = true
+
+[dependency-groups]
+dev = [
+    "coverage>=7.13.5",
+    "prek>=0.3.8",
+    "pytest>=9.0.2",
+    "pytest-alembic>=0.12.1",
+    "pytest-asyncio>=1.3.0",
+    "pytest-cov>=7.1.0",
+    "ruff>=0.15.9",
+]

inifastapi-0.1.0/pyrightconfig.json

@@ -0,0 +1,11 @@
+{
+  "venvPath": ".",
+  "venv": ".venv",
+  "include": [
+    "src",
+    "tests"
+  ],
+  "extraPaths": [
+    "src"
+  ]
+}

inifastapi-0.1.0/src/inifastapi/__init__.py

@@ -0,0 +1,7 @@
+"""inifastapi package."""
+
+from .bootstrap import BootstrapError, bootstrap_project
+from .options import ProjectOptions
+from .scaffold import build_plan, scaffold_project
+
+__all__ = ["BootstrapError", "ProjectOptions", "bootstrap_project", "build_plan", "scaffold_project"]

inifastapi-0.1.0/src/inifastapi/__main__.py

@@ -0,0 +1,5 @@
+from .cli import app
+
+
+if __name__ == "__main__":
+    app()

inifastapi-0.1.0/src/inifastapi/bootstrap.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+from pathlib import Path
+import shutil
+import subprocess
+
+from .options import ProjectOptions
+
+
+BASE_DEPENDENCIES = [
+    "fastapi[standard]",
+    "pydantic-settings",
+]
+
+AUTH_DEPENDENCIES = [
+    "python-jose[cryptography]",
+    "passlib[bcrypt]",
+    "python-multipart",
+]
+
+DATABASE_DEPENDENCIES = [
+    "sqlalchemy[asyncio]",
+    "alembic",
+    "asyncpg",
+]
+
+CACHE_DEPENDENCIES = [
+    "redis[hiredis]",
+]
+
+TASK_QUEUE_DEPENDENCIES = [
+    "celery",
+]
+
+DEV_DEPENDENCIES = [
+    "coverage>=7.13.5",
+    "prek>=0.3.8",
+    "pytest>=9.0.2",
+    "pytest-alembic>=0.12.1",
+    "pytest-asyncio>=1.3.0",
+    "pytest-cov>=7.1.0",
+    "ruff>=0.15.9",
+]
+
+
+class BootstrapError(RuntimeError):
+    """Raised when project environment bootstrap cannot be completed."""
+
+
+def runtime_dependencies(options: ProjectOptions) -> list[str]:
+    dependencies = list(BASE_DEPENDENCIES)
+    if options.auth_enabled:
+        dependencies.extend(AUTH_DEPENDENCIES)
+    if options.database_enabled:
+        dependencies.extend(DATABASE_DEPENDENCIES)
+    if options.cache_enabled:
+        dependencies.extend(CACHE_DEPENDENCIES)
+    if options.task_queue_enabled:
+        dependencies.extend(TASK_QUEUE_DEPENDENCIES)
+    return dependencies
+
+
+def dev_dependencies() -> list[str]:
+    return list(DEV_DEPENDENCIES)
+
+
+def bootstrap_project(options: ProjectOptions) -> None:
+    if shutil.which("uv") is None:
+        raise BootstrapError(
+            "Generated project files, but could not bootstrap the environment because `uv` "
+            "is not installed. Install `uv`, then run `uv sync` in "
+            f"'{options.target_dir}'. For one-off usage, prefer "
+            f"`uvx inifastapi init {options.project_name}`."
+        )
+
+    runtime = runtime_dependencies(options)
+    if runtime:
+        run_uv(["uv", "add", "--no-sync", *runtime], cwd=options.target_dir)
+
+    dev = dev_dependencies()
+    if dev:
+        run_uv(["uv", "add", "--dev", "--no-sync", *dev], cwd=options.target_dir)
+
+    run_uv(["uv", "sync"], cwd=options.target_dir)
+
+
+def run_uv(command: list[str], *, cwd: Path) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        command,
+        cwd=cwd,
+        check=True,
+        text=True,
+        capture_output=True,
+    )

inifastapi-0.1.0/src/inifastapi/cli.py

@@ -0,0 +1,173 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+import typer
+
+from .bootstrap import BootstrapError
+from .options import ProjectOptions, normalize_package_name
+from .scaffold import build_plan, scaffold_project
+
+
+app = typer.Typer(help="Initialize a production-oriented FastAPI project.", no_args_is_help=True)
+
+
+@app.callback()
+def main() -> None:
+    """CLI entrypoint."""
+
+
+def _prompt_text(value: Optional[str], message: str, default: str) -> str:
+    if value:
+        return value
+    return typer.prompt(message, default=default)
+
+
+def _build_options(
+    project_name: str,
+    package_name: Optional[str],
+    target_dir: Optional[Path],
+    app_name: Optional[str],
+    description: Optional[str],
+    python_version: str,
+    host: str,
+    port: int,
+    api_prefix: str,
+    docs_enabled: Optional[bool],
+    cors_enabled: Optional[bool],
+    tests_enabled: Optional[bool],
+    docker_enabled: Optional[bool],
+    ci_enabled: Optional[bool],
+    auth_enabled: Optional[bool],
+    database_enabled: Optional[bool],
+    cache_enabled: Optional[bool],
+    task_queue_enabled: Optional[bool],
+    layout: Optional[str],
+    ci_provider: Optional[str],
+    force: bool,
+    dry_run: bool,
+    bootstrap_env: bool,
+) -> ProjectOptions:
+    suggested_package = normalize_package_name(package_name or "app")
+    chosen_package = _prompt_text(package_name, "Python package name", suggested_package)
+    chosen_target = target_dir or Path(
+        _prompt_text(None, "Target directory", str(Path.cwd() / project_name))
+    )
+    chosen_layout = layout or typer.prompt("Project layout", default="app")
+    chosen_app_name = _prompt_text(app_name, "Application title", project_name.replace("-", " ").title())
+    chosen_description = _prompt_text(description, "Project description", f"{chosen_app_name} service")
+    chosen_docs_enabled = True if docs_enabled is None else docs_enabled
+    chosen_cors_enabled = True if cors_enabled is None else cors_enabled
+    chosen_tests_enabled = True if tests_enabled is None else tests_enabled
+    chosen_database_enabled = False if database_enabled is None else database_enabled
+    chosen_auth_enabled = False if auth_enabled is None else auth_enabled
+    chosen_cache_enabled = False if cache_enabled is None else cache_enabled
+    chosen_task_queue_enabled = False if task_queue_enabled is None else task_queue_enabled
+    chosen_docker_enabled = False if docker_enabled is None else docker_enabled
+    chosen_ci_enabled = False if ci_enabled is None else ci_enabled
+    chosen_ci_provider = ci_provider or "github"
+    if chosen_ci_enabled and ci_provider is None and not dry_run:
+        chosen_ci_provider = typer.prompt("CI provider", default="github")
+
+    return ProjectOptions(
+        project_name=project_name,
+        package_name=chosen_package,
+        target_dir=chosen_target,
+        app_name=chosen_app_name,
+        description=chosen_description,
+        python_version=python_version,
+        host=host,
+        port=port,
+        api_prefix=api_prefix,
+        docs_enabled=chosen_docs_enabled,
+        cors_enabled=chosen_cors_enabled,
+        tests_enabled=chosen_tests_enabled,
+        docker_enabled=chosen_docker_enabled,
+        ci_enabled=chosen_ci_enabled,
+        auth_enabled=chosen_auth_enabled,
+        database_enabled=chosen_database_enabled,
+        cache_enabled=chosen_cache_enabled,
+        task_queue_enabled=chosen_task_queue_enabled,
+        layout=chosen_layout,
+        ci_provider=chosen_ci_provider,
+        force=force,
+        dry_run=dry_run,
+        bootstrap_env=bootstrap_env,
+    )
+
+
+@app.command()
+def init(
+    project_name: str = typer.Argument(..., help="Distribution name for the generated project."),
+    package_name: Optional[str] = typer.Option(None, "--package-name", help="Python package name."),
+    target_dir: Optional[Path] = typer.Option(None, "--target-dir", help="Directory to generate into."),
+    app_name: Optional[str] = typer.Option(None, "--app-name", help="Human-readable app name."),
+    description: Optional[str] = typer.Option(None, "--description", help="Project description."),
+    python_version: str = typer.Option("3.12.10", "--python-version", help="Python version."),
+    host: str = typer.Option("0.0.0.0", "--host", help="Default host."),
+    port: int = typer.Option(8000, "--port", help="Default port."),
+    api_prefix: str = typer.Option("/api/v1", "--api-prefix", help="Global API prefix."),
+    docs_enabled: Optional[bool] = typer.Option(None, "--with-docs/--no-docs"),
+    cors_enabled: Optional[bool] = typer.Option(None, "--with-cors/--no-cors"),
+    tests_enabled: Optional[bool] = typer.Option(None, "--with-tests/--no-tests"),
+    docker_enabled: Optional[bool] = typer.Option(None, "--with-docker/--no-docker"),
+    ci_enabled: Optional[bool] = typer.Option(None, "--with-ci/--no-ci"),
+    auth_enabled: Optional[bool] = typer.Option(None, "--with-auth/--no-auth"),
+    database_enabled: Optional[bool] = typer.Option(None, "--with-database/--no-database"),
+    cache_enabled: Optional[bool] = typer.Option(None, "--with-cache/--no-cache"),
+    task_queue_enabled: Optional[bool] = typer.Option(None, "--with-task-queue/--no-task-queue"),
+    layout: Optional[str] = typer.Option(None, "--layout", help="app or src"),
+    ci_provider: Optional[str] = typer.Option(None, "--ci-provider", help="github or gitlab"),
+    force: bool = typer.Option(False, "--force", help="Overwrite in non-empty directories."),
+    dry_run: bool = typer.Option(False, "--dry-run", help="Only print the files that would be generated."),
+    bootstrap_env: bool = typer.Option(True, "--bootstrap-env/--no-bootstrap-env", help="Create .venv, uv.lock, and install dependencies with uv."),
+) -> None:
+    """Generate a FastAPI project."""
+    options = _build_options(
+        project_name=project_name,
+        package_name=package_name,
+        target_dir=target_dir,
+        app_name=app_name,
+        description=description,
+        python_version=python_version,
+        host=host,
+        port=port,
+        api_prefix=api_prefix,
+        docs_enabled=docs_enabled,
+        cors_enabled=cors_enabled,
+        tests_enabled=tests_enabled,
+        docker_enabled=docker_enabled,
+        ci_enabled=ci_enabled,
+        auth_enabled=auth_enabled,
+        database_enabled=database_enabled,
+        cache_enabled=cache_enabled,
+        task_queue_enabled=task_queue_enabled,
+        layout=layout,
+        ci_provider=ci_provider,
+        force=force,
+        dry_run=dry_run,
+        bootstrap_env=bootstrap_env,
+    )
+
+    try:
+        outputs = scaffold_project(options)
+    except FileExistsError as exc:
+        typer.secho(str(exc), fg=typer.colors.RED, err=True)
+        raise typer.Exit(code=1) from exc
+    except BootstrapError as exc:
+        typer.secho(str(exc), fg=typer.colors.RED, err=True)
+        raise typer.Exit(code=1) from exc
+
+    if options.dry_run:
+        typer.echo(f"Dry run for {options.project_name}:")
+        for path in build_plan(options):
+            typer.echo(f"  would create {path}")
+        return
+
+    typer.secho(f"Generated FastAPI project at {options.target_dir}", fg=typer.colors.GREEN)
+    if options.bootstrap_env:
+        typer.echo("Environment bootstrapped with uv.")
+    typer.echo("Files created:")
+    for path in outputs:
+        typer.echo(f"  {path.relative_to(options.target_dir)}")