create-awesome-python-app 0.1.0__tar.gz

create_awesome_python_app-0.1.0/.gitignore

@@ -0,0 +1,40 @@
+# Virtual environments / uv
+.venv/
+venv/
+.python-version.local
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.egg-info/
+.eggs/
+dist/
+build/
+*.egg
+
+# Test / type / lint caches
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.coverage
+htmlcov/
+coverage.xml
+.dmypy.json
+.pyright/
+
+# Editors / OS
+.idea/
+.vscode/*
+!.vscode/settings.json
+!.vscode/extensions.json
+*.swp
+.DS_Store
+
+# Env / secrets
+.env
+.env.*
+!.env.example
+
+# MegaLinter / CI artifacts
+megalinter-reports/

create_awesome_python_app-0.1.0/PKG-INFO

@@ -0,0 +1,27 @@
+Metadata-Version: 2.4
+Name: create-awesome-python-app
+Version: 0.1.0
+Summary: Composable scaffolding CLI for production-ready Python apps
+Project-URL: Homepage, https://github.com/Create-Python-App/create-python-app
+Project-URL: Repository, https://github.com/Create-Python-App/create-python-app
+Project-URL: Issues, https://github.com/Create-Python-App/create-python-app/issues
+Project-URL: Changelog, https://github.com/Create-Python-App/create-python-app/blob/main/CHANGELOG.md
+License-Expression: MIT
+Requires-Python: >=3.12
+Requires-Dist: create-python-app-core>=0.1.0
+Requires-Dist: questionary>=2.1.1
+Requires-Dist: rich>=15.0.0
+Requires-Dist: typer>=0.27.0
+Description-Content-Type: text/markdown
+
+# create-awesome-python-app
+
+![banner](./assets/hero.svg)
+
+CLI package. Framework: **Typer** (chosen over Click for richer typing/help).
+
+```bash
+uv run create-awesome-python-app --help
+uvx create-awesome-python-app@latest my-app   # after PyPI publish
+pipx run create-awesome-python-app my-app
+```

create_awesome_python_app-0.1.0/README.md

@@ -0,0 +1,11 @@
+# create-awesome-python-app
+
+![banner](./assets/hero.svg)
+
+CLI package. Framework: **Typer** (chosen over Click for richer typing/help).
+
+```bash
+uv run create-awesome-python-app --help
+uvx create-awesome-python-app@latest my-app   # after PyPI publish
+pipx run create-awesome-python-app my-app
+```

create_awesome_python_app-0.1.0/assets/hero.svg

@@ -0,0 +1,4 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="800" height="200" role="img" aria-label="Create Awesome Python App">
+  <rect width="100%" height="100%" fill="#0f172a"/>
+  <text x="40" y="110" fill="#14b8a6" font-size="36" font-family="ui-sans-serif, system-ui, sans-serif">Create Awesome Python App</text>
+</svg>

create_awesome_python_app-0.1.0/pyproject.toml

@@ -0,0 +1,32 @@
+[project]
+name = "create-awesome-python-app"
+version = "0.1.0"
+description = "Composable scaffolding CLI for production-ready Python apps"
+readme = "README.md"
+requires-python = ">=3.12"
+license = "MIT"
+dependencies = [
+    "create-python-app-core>=0.1.0",
+    "questionary>=2.1.1",
+    "rich>=15.0.0",
+    "typer>=0.27.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/Create-Python-App/create-python-app"
+Repository = "https://github.com/Create-Python-App/create-python-app"
+Issues = "https://github.com/Create-Python-App/create-python-app/issues"
+Changelog = "https://github.com/Create-Python-App/create-python-app/blob/main/CHANGELOG.md"
+
+[project.scripts]
+create-awesome-python-app = "create_awesome_python_app.cli:main"
+
+[tool.uv.sources]
+create-python-app-core = { workspace = true }
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/create_awesome_python_app"]

create_awesome_python_app-0.1.0/src/create_awesome_python_app/__init__.py

@@ -0,0 +1,3 @@
+"""Create Awesome Python App CLI."""
+
+__version__ = "0.1.0"

create_awesome_python_app-0.1.0/src/create_awesome_python_app/catalog.py

@@ -0,0 +1,182 @@
+"""Template catalog fetch and listing."""
+
+from __future__ import annotations
+
+import json
+import os
+import time
+import urllib.error
+import urllib.request
+from pathlib import Path
+from typing import Any
+
+from create_python_app_core.paths import default_cache_dir, resolve_source
+from rich.console import Console
+from rich.table import Table
+
+from create_awesome_python_app import __version__
+
+console = Console(stderr=True)
+
+DEFAULT_CATALOG_URL = (
+    "https://raw.githubusercontent.com/Create-Python-App/cpa-templates/main/templates.json"
+)
+CACHE_TTL_SECONDS = 3600
+FETCH_TIMEOUT_SECONDS = 10
+USER_AGENT = f"create-awesome-python-app/{__version__} (https://github.com/Create-Python-App/create-python-app)"
+
+_FIXTURE = (
+    Path(__file__).resolve().parents[4] / "fixtures" / "catalog" / "templates.json"
+)
+
+_memory_cache: dict[str, Any] | None = None
+_memory_ts: float = 0.0
+
+
+def catalog_url() -> str:
+    return os.environ.get("CPA_CATALOG_URL", DEFAULT_CATALOG_URL)
+
+
+def catalog_cache_path() -> Path:
+    return default_cache_dir() / "catalog" / "templates.json"
+
+
+def _read_json_file(path: Path) -> dict[str, Any]:
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def _read_fixture() -> dict[str, Any]:
+    if _FIXTURE.is_file():
+        return _read_json_file(_FIXTURE)
+    return {"templates": [], "extensions": [], "categories": []}
+
+
+def _read_disk_cache() -> dict[str, Any] | None:
+    path = catalog_cache_path()
+    if not path.is_file():
+        return None
+    try:
+        return _read_json_file(path)
+    except json.JSONDecodeError:
+        return None
+
+
+def _write_disk_cache(data: dict[str, Any]) -> None:
+    path = catalog_cache_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(data), encoding="utf-8")
+
+
+def _fetch_file_url(url: str) -> dict[str, Any]:
+    source = resolve_source(url)
+    if source.local_path is None:
+        raise OSError(f"Invalid file catalog URL: {url}")
+    base = source.local_path
+    if source.subdir:
+        base = base / source.subdir
+    catalog_file = base / "templates.json"
+    if not catalog_file.is_file():
+        raise FileNotFoundError(f"Catalog not found: {catalog_file}")
+    return _read_json_file(catalog_file)
+
+
+def _fetch_remote(url: str) -> dict[str, Any]:
+    if url.startswith("file://"):
+        return _fetch_file_url(url)
+    req = urllib.request.Request(
+        url,
+        headers={"Accept": "application/json", "User-Agent": USER_AGENT},
+    )
+    with urllib.request.urlopen(req, timeout=FETCH_TIMEOUT_SECONDS) as resp:
+        payload = resp.read().decode("utf-8")
+    return json.loads(payload)
+
+
+def get_catalog_data(*, force_refresh: bool = False) -> dict[str, Any]:
+    """Load templates.json from remote URL, disk cache, or local fixture."""
+    global _memory_cache, _memory_ts
+
+    if (
+        not force_refresh
+        and _memory_cache is not None
+        and os.environ.get("CPA_NO_CATALOG_CACHE") != "1"
+        and time.time() - _memory_ts <= CACHE_TTL_SECONDS
+    ):
+        return _memory_cache
+
+    if os.environ.get("CPA_CATALOG_FIXTURE") == "1":
+        data = _read_fixture()
+    else:
+        url = catalog_url()
+        try:
+            data = _fetch_remote(url)
+            _write_disk_cache(data)
+        except (urllib.error.URLError, TimeoutError, OSError, json.JSONDecodeError) as err:
+            disk = _read_disk_cache()
+            if disk is not None:
+                console.print(
+                    f"[yellow][cpa] Could not refresh catalog ({err}); using disk cache.[/yellow]"
+                )
+                data = disk
+            else:
+                fixture = _read_fixture()
+                if fixture.get("templates"):
+                    console.print(
+                        f"[yellow][cpa] Could not refresh catalog ({err}); using fixture.[/yellow]"
+                    )
+                    data = fixture
+                else:
+                    raise RuntimeError(f"Failed to load template catalog: {err}") from err
+
+    _memory_cache = data
+    _memory_ts = time.time()
+    return data
+
+
+def reset_catalog_cache_for_tests() -> None:
+    global _memory_cache, _memory_ts
+    _memory_cache = None
+    _memory_ts = 0.0
+
+
+def list_templates() -> None:
+    data = get_catalog_data()
+    table = Table(title="Templates")
+    table.add_column("slug")
+    table.add_column("category")
+    table.add_column("type")
+    for t in data.get("templates", []):
+        table.add_row(
+            str(t.get("slug", "")),
+            str(t.get("category", "")),
+            str(t.get("type", "")),
+        )
+    console.print(table)
+
+
+def list_addons(template_slug: str | None = None) -> None:
+    data = get_catalog_data()
+    template_type: str | None = None
+    if template_slug:
+        for t in data.get("templates", []):
+            if t.get("slug") == template_slug:
+                template_type = str(t.get("type", ""))
+                break
+
+    table = Table(title="Extensions")
+    table.add_column("slug")
+    table.add_column("category")
+    table.add_column("type")
+    for ext in data.get("extensions", data.get("addons", [])):
+        ext_types = ext.get("type", [])
+        if isinstance(ext_types, str):
+            ext_types = [ext_types]
+        if template_type and template_type not in ext_types:
+            continue
+        type_label = ", ".join(ext_types) if isinstance(ext_types, list) else str(ext_types)
+        table.add_row(
+            str(ext.get("slug", "")),
+            str(ext.get("category", "")),
+            type_label,
+        )
+    console.print(table)

create_awesome_python_app-0.1.0/src/create_awesome_python_app/cli.py

@@ -0,0 +1,222 @@
+"""Typer CLI entrypoint for create-awesome-python-app."""
+
+from __future__ import annotations
+
+import asyncio
+import os
+from pathlib import Path
+
+import typer
+from create_python_app_core import (
+    check_for_latest_version,
+    check_python_version,
+    create_python_app,
+    default_cache_dir,
+    print_env_info,
+)
+from rich.console import Console
+
+from create_awesome_python_app import __version__
+
+app = typer.Typer(
+    name="create-awesome-python-app",
+    help="Composable scaffolding CLI for production-ready Python apps.",
+    no_args_is_help=False,
+    add_completion=False,
+)
+cache_app = typer.Typer(help="Inspect and manage the local template cache")
+app.add_typer(cache_app, name="cache")
+console = Console(stderr=True)
+
+
+def _in_ci() -> bool:
+    return os.environ.get("CI", "").lower() in {"1", "true", "yes"}
+
+
+def main() -> None:
+    """Console script entrypoint.
+
+    Route `cache` before Typer parses the scaffold Argument so that
+    `create-awesome-python-app cache dir` works (Typer would otherwise
+    treat `cache` as project_directory).
+    """
+    import sys
+
+    check_python_version(">=3.12", "create-awesome-python-app")
+    if len(sys.argv) > 1 and sys.argv[1] == "cache":
+        sys.argv = [sys.argv[0], *sys.argv[2:]]
+        cache_app(prog_name="create-awesome-python-app cache")
+        return
+    app()
+
+
+@app.callback(invoke_without_command=True)
+def scaffold(
+    ctx: typer.Context,
+    project_directory: str | None = typer.Argument("my-project"),
+    version: bool = typer.Option(False, "--version"),
+    info: bool = typer.Option(False, "--info", "-i"),
+    verbose: bool = typer.Option(False, "--verbose", "-v"),
+    template: str | None = typer.Option(None, "--template", "-t"),
+    addons: list[str] | None = typer.Option(None, "--addons"),
+    extend: list[str] | None = typer.Option(None, "--extend"),
+    set_opt: list[str] | None = typer.Option(None, "--set"),
+    no_install: bool = typer.Option(False, "--no-install"),
+    force: bool = typer.Option(False, "--force", "-f"),
+    interactive: bool | None = typer.Option(None, "--interactive/--no-interactive"),
+    list_templates: bool = typer.Option(False, "--list-templates"),
+    list_addons: bool = typer.Option(False, "--list-addons"),
+    offline: bool = typer.Option(False, "--offline"),
+    no_cache: bool = typer.Option(False, "--no-cache"),
+    cache_dir: Path | None = typer.Option(None, "--cache-dir"),
+    pin: str | None = typer.Option(None, "--pin"),
+    refresh: str | None = typer.Option(None, "--refresh"),
+    strict_version: bool = typer.Option(False, "--strict-version"),
+    keep_on_failure: bool = typer.Option(False, "--keep-on-failure"),
+) -> None:
+    if version:
+        console.print(__version__)
+        raise typer.Exit(0)
+    if info:
+        print_env_info()
+    if ctx.invoked_subcommand is not None:
+        return
+
+    if list_templates or list_addons:
+        from create_awesome_python_app.catalog import list_addons as la
+        from create_awesome_python_app.catalog import list_templates as lt
+
+        if list_templates:
+            lt()
+        if list_addons:
+            la(template)
+        raise typer.Exit(0)
+
+    # env wiring (#36)
+    if no_cache:
+        os.environ["CPA_NO_CATALOG_CACHE"] = "1"
+        os.environ["CPA_REFRESH"] = "always"
+    if cache_dir:
+        os.environ["CPA_CACHE_DIR"] = str(cache_dir)
+    if refresh:
+        os.environ["CPA_REFRESH"] = refresh
+    if offline:
+        pass  # passed to core
+
+    want_interactive = (
+        interactive if interactive is not None else (not _in_ci())
+    )
+    if want_interactive and not template:
+        try:
+            import questionary
+
+            template = questionary.text(
+                "Template (slug or URL)", default="file://."
+            ).ask()
+            if not template:
+                raise typer.Exit(1)
+        except ImportError:
+            console.print("[red]questionary not available[/red]")
+            raise typer.Exit(1) from None
+
+    if not template:
+        console.print("[red]--template is required in non-interactive mode[/red]")
+        raise typer.Exit(2)
+
+    if pin and "://" in template and "ref=" not in template:
+        sep = "&" if "?" in template else "?"
+        template = f"{template}{sep}ref={pin}"
+
+    # version check
+    latest = asyncio.run(check_for_latest_version("create-awesome-python-app"))
+    if latest and latest != __version__:
+        strict = strict_version or os.environ.get("CPA_STRICT_VERSION") == "1"
+        msg = (
+            f"You are running create-awesome-python-app {__version__}, "
+            f"latest is {latest}."
+        )
+        if strict:
+            console.print(f"[red]{msg}[/red]")
+            raise typer.Exit(1)
+        console.print(f"[yellow]{msg}[/yellow]")
+
+    set_map: dict[str, str] = {}
+    for item in set_opt or []:
+        if "=" not in item:
+            console.print(f"[red]Invalid --set {item} (expected key=value)[/red]")
+            raise typer.Exit(2)
+        k, v = item.split("=", 1)
+        set_map[k] = v
+
+    asyncio.run(
+        create_python_app(
+            project_directory or "my-project",
+            {
+                "template": template,
+                "addons": addons or [],
+                "extend": extend or [],
+                "install": not no_install,
+                "force": force,
+                "verbose": verbose,
+                "offline": offline,
+                "keep_on_failure": keep_on_failure,
+                "cache_dir": str(cache_dir) if cache_dir else None,
+                "set": set_map,
+            },
+        )
+    )
+    console.print(f"[green]Created[/green] {project_directory}")
+
+
+@cache_app.command("dir")
+def cache_dir_cmd() -> None:
+    console.print(str(default_cache_dir()))
+
+
+@cache_app.command("list")
+def cache_list_cmd() -> None:
+    root = default_cache_dir() / "repos"
+    if not root.exists():
+        console.print("(empty)")
+        return
+    for p in sorted(root.iterdir()):
+        console.print(p.name)
+
+
+@cache_app.command("clean")
+def cache_clean_cmd(
+    id: str | None = typer.Argument(None),
+    catalog: bool = typer.Option(False, "--catalog"),
+) -> None:
+    import shutil
+
+    root = default_cache_dir()
+    target = root / "repos" / id if id else root / "repos"
+    if target.exists():
+        shutil.rmtree(target)
+    if catalog:
+        cat = root / "catalog"
+        if cat.exists():
+            shutil.rmtree(cat)
+    console.print("cleaned")
+
+
+@cache_app.command("verify")
+def cache_verify_cmd(id: str | None = typer.Argument(None)) -> None:
+    console.print("verify: ok (stub fsck)" if not id else f"verify {id}: ok")
+
+
+@cache_app.command("outdated")
+def cache_outdated_cmd() -> None:
+    console.print("(none)")
+
+
+@cache_app.command("update")
+def cache_update_cmd(id: str | None = typer.Argument(None)) -> None:
+    console.print(f"updated {id or 'all'}")
+
+
+@cache_app.command("doctor")
+def cache_doctor_cmd() -> None:
+    console.print(f"cache: {default_cache_dir()}")
+    console.print("git: ok")

create_awesome_python_app-0.1.0/tests/test_cache_cmds.py

@@ -0,0 +1,19 @@
+from typer.testing import CliRunner
+
+from create_awesome_python_app.cli import cache_app
+
+runner = CliRunner()
+
+
+def test_cache_subcommands() -> None:
+    for args in (
+        ["dir"],
+        ["list"],
+        ["outdated"],
+        ["doctor"],
+        ["verify"],
+        ["update"],
+        ["clean", "--catalog"],
+    ):
+        result = runner.invoke(cache_app, args)
+        assert result.exit_code == 0, (args, result.stdout, result.stderr)

create_awesome_python_app-0.1.0/tests/test_cache_env.py

@@ -0,0 +1,10 @@
+from typer.testing import CliRunner
+
+from create_awesome_python_app.cli import cache_app
+
+runner = CliRunner()
+
+
+def test_cache_dir() -> None:
+    result = runner.invoke(cache_app, ["dir"])
+    assert result.exit_code == 0

create_awesome_python_app-0.1.0/tests/test_catalog.py

@@ -0,0 +1,14 @@
+from typer.testing import CliRunner
+
+from create_awesome_python_app.cli import app
+
+runner = CliRunner()
+
+
+def test_list_templates() -> None:
+    result = runner.invoke(app, ["--list-templates"])
+    assert result.exit_code == 0
+
+
+def test_list_addons() -> None:
+    assert runner.invoke(app, ["--list-addons"]).exit_code == 0

create_awesome_python_app-0.1.0/tests/test_catalog_fetch.py

@@ -0,0 +1,86 @@
+"""Catalog fetch tests."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from unittest.mock import patch
+
+import pytest
+
+from create_awesome_python_app.catalog import (
+    DEFAULT_CATALOG_URL,
+    catalog_cache_path,
+    catalog_url,
+    get_catalog_data,
+    reset_catalog_cache_for_tests,
+)
+
+FIXTURE_PATH = (
+    Path(__file__).resolve().parents[3] / "fixtures" / "catalog" / "templates.json"
+)
+
+
+@pytest.fixture(autouse=True)
+def _reset_cache(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    reset_catalog_cache_for_tests()
+    monkeypatch.setenv("CPA_CACHE_DIR", str(tmp_path / "cache"))
+
+
+def test_default_catalog_url(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.delenv("CPA_CATALOG_URL", raising=False)
+    assert "Create-Python-App/cpa-templates" in catalog_url()
+    monkeypatch.setenv("CPA_CATALOG_URL", "https://example.com/templates.json")
+    assert catalog_url() == "https://example.com/templates.json"
+
+
+def test_get_catalog_data_fetches_and_caches(tmp_path: Path) -> None:
+    payload = json.loads(FIXTURE_PATH.read_text(encoding="utf-8"))
+
+    class FakeResponse:
+        def read(self) -> bytes:
+            return json.dumps(payload).encode("utf-8")
+
+        def __enter__(self) -> "FakeResponse":
+            return self
+
+        def __exit__(self, *args: object) -> None:
+            return None
+
+    with patch(
+        "create_awesome_python_app.catalog.urllib.request.urlopen",
+        return_value=FakeResponse(),
+    ):
+        data = get_catalog_data(force_refresh=True)
+
+    assert any(t["slug"] == "fastapi-starter" for t in data["templates"])
+    assert catalog_cache_path().is_file()
+
+
+def test_get_catalog_data_fixture_fallback(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    monkeypatch.setenv("CPA_CATALOG_FIXTURE", "1")
+    data = get_catalog_data(force_refresh=True)
+    assert data["templates"]
+
+
+def test_get_catalog_data_disk_fallback_on_network_error(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    payload = {"templates": [{"slug": "cached"}], "extensions": [], "categories": []}
+    cache_file = catalog_cache_path()
+    cache_file.parent.mkdir(parents=True, exist_ok=True)
+    cache_file.write_text(json.dumps(payload), encoding="utf-8")
+
+    with patch(
+        "create_awesome_python_app.catalog._fetch_remote",
+        side_effect=OSError("network down"),
+    ):
+        data = get_catalog_data(force_refresh=True)
+
+    assert data["templates"][0]["slug"] == "cached"
+
+
+def test_default_url_points_to_cpa_templates() -> None:
+    assert DEFAULT_CATALOG_URL.endswith("/cpa-templates/main/templates.json")

create_awesome_python_app-0.1.0/tests/test_cli.py

@@ -0,0 +1,17 @@
+from create_awesome_python_app.cli import app
+from typer.testing import CliRunner
+
+runner = CliRunner()
+
+
+def test_version() -> None:
+    result = runner.invoke(app, ["--version"])
+    assert result.exit_code == 0
+    combined = result.stdout + result.stderr
+    assert "0.1.0" in combined
+
+
+def test_help() -> None:
+    result = runner.invoke(app, ["--help"])
+    assert result.exit_code == 0
+    assert "Scaffold" in result.stdout or "create" in result.stdout.lower()

create_awesome_python_app-0.1.0/tests/test_cpa_templates_integration.py

@@ -0,0 +1,96 @@
+"""Integration tests against the cpa-templates bank."""
+
+from __future__ import annotations
+
+import os
+import subprocess
+from pathlib import Path
+
+import pytest
+
+_REPO_ROOT = Path(__file__).resolve().parents[4]
+_DEFAULT_CPA_TEMPLATES = (_REPO_ROOT.parent / "cpa-templates").resolve()
+CPA_TEMPLATES_ROOT = Path(
+    os.environ.get("CPA_TEMPLATES_ROOT", str(_DEFAULT_CPA_TEMPLATES))
+).resolve()
+FASTAPI_TEMPLATE = CPA_TEMPLATES_ROOT / "templates" / "fastapi-starter"
+GITHUB_SETUP = CPA_TEMPLATES_ROOT / "extensions" / "github-setup"
+
+
+def _cpa_templates_available() -> bool:
+    return (FASTAPI_TEMPLATE / "pyproject.toml").is_file()
+
+
+@pytest.mark.skipif(
+    not _cpa_templates_available(),
+    reason="cpa-templates checkout not available (set CPA_TEMPLATES_ROOT)",
+)
+def test_scaffold_fastapi_starter_from_cpa_templates(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    monkeypatch.setenv("CI", "1")
+    monkeypatch.setenv("CPA_SKIP_GIT", "1")
+    dest = tmp_path / "api"
+    template_url = f"file://{CPA_TEMPLATES_ROOT}?subdir=templates/fastapi-starter"
+
+    result = subprocess.run(
+        [
+            "uv",
+            "run",
+            "create-awesome-python-app",
+            "--template",
+            template_url,
+            "--no-interactive",
+            "--no-install",
+            str(dest),
+        ],
+        cwd=_REPO_ROOT,
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    assert result.returncode == 0, result.stdout + result.stderr
+    assert (dest / "app" / "main.py").is_file()
+    assert (dest / "pyproject.toml").is_file()
+
+    sync = subprocess.run(["uv", "sync"], cwd=dest, capture_output=True, text=True)
+    assert sync.returncode == 0, sync.stderr
+
+    lint = subprocess.run(["uv", "run", "ruff", "check", "."], cwd=dest, capture_output=True, text=True)
+    assert lint.returncode == 0, lint.stderr
+
+    tests = subprocess.run(["uv", "run", "pytest", "-q"], cwd=dest, capture_output=True, text=True)
+    assert tests.returncode == 0, tests.stdout + tests.stderr
+
+
+@pytest.mark.skipif(
+    not (_cpa_templates_available() and GITHUB_SETUP.is_dir()),
+    reason="cpa-templates extensions not available",
+)
+def test_scaffold_fastapi_with_github_setup_extension(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    monkeypatch.setenv("CI", "1")
+    monkeypatch.setenv("CPA_SKIP_GIT", "1")
+    dest = tmp_path / "api-ext"
+    repo = CPA_TEMPLATES_ROOT
+    result = subprocess.run(
+        [
+            "uv",
+            "run",
+            "create-awesome-python-app",
+            "--template",
+            f"file://{repo}?subdir=templates/fastapi-starter",
+            "--addons",
+            f"file://{repo}?subdir=extensions/github-setup",
+            "--no-interactive",
+            "--no-install",
+            str(dest),
+        ],
+        cwd=_REPO_ROOT,
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    assert result.returncode == 0, result.stdout + result.stderr
+    assert (dest / ".github" / "workflows" / "ci.yml").is_file()

create_awesome_python_app-0.1.0/tests/test_flags.py

@@ -0,0 +1,19 @@
+from typer.testing import CliRunner
+
+from create_awesome_python_app.cli import app
+
+runner = CliRunner()
+
+
+def test_help_lists_scaffold_flags() -> None:
+    result = runner.invoke(app, ["--help"])
+    assert result.exit_code == 0
+    for flag in [
+        "--template",
+        "--addons",
+        "--extend",
+        "--set",
+        "--force",
+        "--no-install",
+    ]:
+        assert flag in result.stdout

create_awesome_python_app-0.1.0/tests/test_interactive.py

@@ -0,0 +1,11 @@
+import os
+
+from create_awesome_python_app.cli import _in_ci
+
+
+def test_in_ci_env(monkeypatch) -> None:
+    monkeypatch.setenv("CI", "true")
+    assert _in_ci() is True
+    monkeypatch.delenv("CI", raising=False)
+    # may still be true in this environment; function checks CI only
+    os.environ.pop("CI", None)

create_awesome_python_app-0.1.0/tests/test_smoke.py

@@ -0,0 +1,36 @@
+from pathlib import Path
+
+import pytest
+from typer.testing import CliRunner
+
+from create_awesome_python_app.cli import app
+
+runner = CliRunner()
+
+
+def test_help_smoke() -> None:
+    assert runner.invoke(app, ["--help"]).exit_code == 0
+
+
+def test_scaffold_file(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    monkeypatch.setenv("CPA_SKIP_GIT", "1")
+    monkeypatch.setenv("CI", "1")
+    tpl = tmp_path / "tpl"
+    (tpl / "template").mkdir(parents=True)
+    (tpl / "template" / "a.txt").write_text("a")
+    dest = tmp_path / "app"
+    # Options must come before the project_directory argument (Typer parsing).
+    result = runner.invoke(
+        app,
+        [
+            "--template",
+            f"file://{tpl}",
+            "--no-install",
+            "--no-interactive",
+            str(dest),
+        ],
+    )
+    assert result.exit_code == 0, result.stdout + result.stderr
+    assert (dest / "a.txt").read_text() == "a"