create-awesome-python-app 0.1.0__py3-none-any.whl

create_awesome_python_app/__init__.py

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

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/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.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,7 @@
+create_awesome_python_app/__init__.py,sha256=1I7wHHoj96peEdOGE_jNwR1U2t_8AmnNUZRidc_-CCI,60
+create_awesome_python_app/catalog.py,sha256=MM4lvEGxdPrho9CkGairhT0nYy_eesVgD1wGyJx3gaM,5564
+create_awesome_python_app/cli.py,sha256=kbxeFaroiDe_UhHyM6lt5VhkDzixoCaMmudFLvZAvsI,7012
+create_awesome_python_app-0.1.0.dist-info/METADATA,sha256=iqsjgMLGNgRigLM2pVsiceZwew6S6gHiwL8EP2ixDu0,1005
+create_awesome_python_app-0.1.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+create_awesome_python_app-0.1.0.dist-info/entry_points.txt,sha256=rszFbUjY-lvMDZ96zX1lALJwgD1mI3CkUuNyF2qqjYo,81
+create_awesome_python_app-0.1.0.dist-info/RECORD,,

create_awesome_python_app-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

create_awesome_python_app-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+create-awesome-python-app = create_awesome_python_app.cli:main