create-awesome-python-app 0.2.6__py3-none-any.whl → 0.2.8__py3-none-any.whl

create_awesome_python_app/__init__.py

@@ -1,3 +1,3 @@
 """Create Awesome Python App CLI."""
 
-__version__ = "0.2.6"
+__version__ = "0.2.8"

create_awesome_python_app/catalog.py

@@ -13,7 +13,6 @@ 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__
 from create_awesome_python_app.prompt_style import (
@@ -159,6 +158,17 @@ def validate_extension_compatibility(
         raise IncompatibleExtensionsError(pairs)
 
 
+@dataclass(frozen=True)
+class CategoryInfo:
+    """Catalog category with optional rich metadata (CNA parity)."""
+
+    slug: str
+    name: str
+    description: str = ""
+    details: str = ""
+    labels: tuple[str, ...] = ()
+
+
 def short_category_label(category_name: str) -> str:
     """Derive a compact badge label from a catalog category name."""
     stop_words = {"Applications", "Application", "Boilerplate"}
@@ -168,11 +178,48 @@ def short_category_label(category_name: str) -> str:
     return " ".join(words[:2]) or category_name
 
 
+def category_index(data: dict[str, Any]) -> dict[str, CategoryInfo]:
+    """Index categories by slug, including description/details/labels."""
+    out: dict[str, CategoryInfo] = {}
+    for raw in data.get("categories", []):
+        if not isinstance(raw, dict):
+            continue
+        slug = str(raw.get("slug", "")).strip()
+        if not slug:
+            continue
+        labels_raw = raw.get("labels", [])
+        labels = (
+            tuple(str(label) for label in labels_raw)
+            if isinstance(labels_raw, list)
+            else ()
+        )
+        out[slug] = CategoryInfo(
+            slug=slug,
+            name=str(raw.get("name", slug)),
+            description=str(raw.get("description", "")).strip(),
+            details=str(raw.get("details", "")).strip(),
+            labels=labels,
+        )
+    return out
+
+
+def get_category_data(data: dict[str, Any], slug: str) -> CategoryInfo | None:
+    return category_index(data).get(slug)
+
+
+def format_category_choice_title(info: CategoryInfo, extension_count: int) -> str:
+    """Human title for the interactive extension-category picker."""
+    noun = "extension" if extension_count == 1 else "extensions"
+    title = f"{info.name} ({extension_count} {noun})"
+    if info.description:
+        title = f"{title} — {info.description}"
+    if info.labels:
+        title = f"{title} · {', '.join(info.labels[:3])}"
+    return title
+
+
 def _category_map(data: dict[str, Any]) -> dict[str, str]:
-    return {
-        str(category.get("slug", "")): str(category.get("name", ""))
-        for category in data.get("categories", [])
-    }
+    return {slug: info.name for slug, info in category_index(data).items()}
 
 
 def _search_text(template: dict[str, Any], category_name: str) -> str:
@@ -344,9 +391,9 @@ 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"
-)
+_AUTO_FIXTURE_DIR = Path(__file__).resolve().parents[4]
+_SENTINEL = object()
+_fixture_root_override: Path | None | object = _SENTINEL
 
 _memory_cache: dict[str, Any] | None = None
 _memory_ts: float = 0.0
@@ -360,13 +407,61 @@ def catalog_cache_path() -> Path:
     return default_cache_dir() / "catalog" / "templates.json"
 
 
+def resolve_fixture_root() -> Path | None:
+    """Resolve the repo root that contains ``fixtures/catalog/templates.json``.
+
+    Priority: ``CPA_FIXTURE_DIR`` → walk-up from package → ``cwd``.
+    """
+    if _fixture_root_override is not _SENTINEL:
+        return _fixture_root_override  # type: ignore[return-value]
+
+    env = os.environ.get("CPA_FIXTURE_DIR", "").strip()
+    if env:
+        return Path(env).expanduser().resolve()
+
+    def _has_fixture_catalog(root: Path) -> bool:
+        return (root / "fixtures" / "catalog" / "templates.json").is_file()
+
+    if _has_fixture_catalog(_AUTO_FIXTURE_DIR):
+        return _AUTO_FIXTURE_DIR
+
+    # Editable / site-packages layouts vary; walk up from this file.
+    for parent in Path(__file__).resolve().parents:
+        if _has_fixture_catalog(parent):
+            return parent
+
+    cwd = Path.cwd()
+    if _has_fixture_catalog(cwd):
+        return cwd
+    return None
+
+
+def set_fixture_root_for_tests(root: Path | None) -> None:
+    """Override fixture root (test helper)."""
+    global _fixture_root_override
+    _fixture_root_override = root
+
+
+def reset_fixture_root_for_tests() -> None:
+    global _fixture_root_override
+    _fixture_root_override = _SENTINEL
+
+
+def fixture_catalog_path() -> Path | None:
+    root = resolve_fixture_root()
+    if root is None:
+        return None
+    return root / "fixtures" / "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)
+    path = fixture_catalog_path()
+    if path is not None and path.is_file():
+        return _read_json_file(path)
     return {"templates": [], "extensions": [], "categories": []}
 
 
@@ -417,6 +512,19 @@ 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 os.environ.get("CPA_CATALOG_FIXTURE") == "1":
+        path = fixture_catalog_path()
+        if path is None or not path.is_file():
+            raise RuntimeError(
+                "Fixture mode is enabled (CPA_CATALOG_FIXTURE=1) but the fixture "
+                "root could not be resolved. Set CPA_FIXTURE_DIR to the repo root "
+                "containing fixtures/catalog/templates.json."
+            )
+        data = _read_fixture()
+        _memory_cache = data
+        _memory_ts = time.time()
+        return data
+
     if (
         not force_refresh
         and _memory_cache is not None
@@ -425,38 +533,33 @@ def get_catalog_data(*, force_refresh: bool = False) -> dict[str, Any]:
     ):
         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:
+    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(
+                "[yellow][cpa] Could not refresh catalog "
+                f"({err}); using disk cache.[/yellow]"
+            )
+            data = disk
+        else:
+            fixture = _read_fixture()
+            if fixture.get("templates"):
                 console.print(
                     "[yellow][cpa] Could not refresh catalog "
-                    f"({err}); using disk cache.[/yellow]"
+                    f"({err}); using fixture.[/yellow]"
                 )
-                data = disk
+                data = fixture
             else:
-                fixture = _read_fixture()
-                if fixture.get("templates"):
-                    console.print(
-                        "[yellow][cpa] Could not refresh catalog "
-                        f"({err}); using fixture.[/yellow]"
-                    )
-                    data = fixture
-                else:
-                    raise RuntimeError(
-                        f"Failed to load template catalog: {err}"
-                    ) from err
+                raise RuntimeError(f"Failed to load template catalog: {err}") from err
 
     _memory_cache = data
     _memory_ts = time.time()
@@ -471,44 +574,96 @@ def reset_catalog_cache_for_tests() -> None:
 
 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)
+    categories = category_index(data)
+    templates = [t for t in data.get("templates", []) if isinstance(t, dict)]
+
+    console.print("[bold blue]\nAvailable Templates:[/bold blue]")
+    # Preserve catalog category order, then any unknown slugs.
+    ordered_slugs = list(categories)
+    seen: set[str] = set()
+    for slug in ordered_slugs:
+        seen.add(slug)
+        group = [t for t in templates if str(t.get("category", "")) == slug]
+        if not group:
+            continue
+        info = categories[slug]
+        console.print(f"[bold green]\n{info.name}:[/bold green]")
+        if info.description:
+            console.print(f"  {info.description}")
+        if info.details:
+            console.print(f"  [dim]{info.details}[/dim]")
+        if info.labels:
+            console.print(f"  [dim]Keywords: {', '.join(info.labels)}[/dim]")
+        for template in group:
+            name = str(template.get("name", template.get("slug", "")))
+            tslug = str(template.get("slug", ""))
+            console.print(f"  [yellow]{name}[/yellow] ([cyan]{tslug}[/cyan])")
+            desc = str(template.get("description", "")).strip()
+            if desc:
+                console.print(f"    {desc}")
+            labels = template.get("labels", [])
+            if isinstance(labels, list) and labels:
+                console.print(f"    Keywords: {', '.join(str(x) for x in labels)}")
+
+    orphans = [t for t in templates if str(t.get("category", "")) not in seen]
+    if orphans:
+        console.print("[bold green]\nOther:[/bold green]")
+        for template in orphans:
+            name = str(template.get("name", template.get("slug", "")))
+            tslug = str(template.get("slug", ""))
+            console.print(f"  [yellow]{name}[/yellow] ([cyan]{tslug}[/cyan])")
 
 
 def list_addons(template_slug: str | None = None) -> None:
     data = get_catalog_data()
+    categories = category_index(data)
     template_type: str | None = None
     if template_slug:
         for t in data.get("templates", []):
-            if t.get("slug") == template_slug:
+            if isinstance(t, dict) and 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", [])):
+    console.print("[bold blue]\nAvailable Addons:[/bold blue]")
+    if template_slug:
+        console.print(
+            f"[bold green]\nCompatible with template: {template_slug}[/bold green]"
+        )
+
+    extensions = [
+        ext
+        for ext in data.get("extensions", data.get("addons", []))
+        if isinstance(ext, dict)
+    ]
+    grouped: dict[str, list[dict[str, Any]]] = {}
+    for ext in extensions:
         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)
+        slug = str(ext.get("category", "custom"))
+        grouped.setdefault(slug, []).append(ext)
+
+    for slug in list(categories) + [s for s in grouped if s not in categories]:
+        group = grouped.get(slug)
+        if not group:
+            continue
+        info = categories.get(slug) or CategoryInfo(slug=slug, name=slug)
+        console.print(f"[bold green]\n{info.name}:[/bold green]")
+        if info.description:
+            console.print(f"  {info.description}")
+        if info.details:
+            console.print(f"  [dim]{info.details}[/dim]")
+        if info.labels:
+            console.print(f"  [dim]Keywords: {', '.join(info.labels)}[/dim]")
+        for ext in group:
+            name = str(ext.get("name", ext.get("slug", "")))
+            eslug = str(ext.get("slug", ""))
+            console.print(f"  [yellow]{name}[/yellow] ([cyan]{eslug}[/cyan])")
+            desc = str(ext.get("description", "")).strip()
+            if desc:
+                console.print(f"    {desc}")
+            labels = ext.get("labels", [])
+            if isinstance(labels, list) and labels:
+                console.print(f"    Keywords: {', '.join(str(x) for x in labels)}")

create_awesome_python_app/cli.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import asyncio
 import os
+import sys
 from pathlib import Path
 from typing import Any
 
@@ -25,17 +26,103 @@ from rich.console import Console
 
 from create_awesome_python_app import __version__
 
+# Sentinel for bare ``--fixture`` (optional DIR rewritten in argv preprocess).
+_FIXTURE_AUTO = "__CPA_FIXTURE_AUTO__"
+
 app = typer.Typer(
     name="create-awesome-python-app",
     help="Composable scaffolding CLI for production-ready Python apps.",
     no_args_is_help=False,
     add_completion=True,
+    # Keep cache out of this Typer app (routed in main()). A nested command
+    # group turns the CLI into Click Group form `[ARGS] COMMAND`, so
+    # `cpa my-api --template …` fails with "No such command '--template'".
+    epilog="Cache: create-awesome-python-app cache [list|dir|clean|verify|…]",
 )
 cache_app = typer.Typer(help="Inspect and manage the local template cache")
-app.add_typer(cache_app, name="cache")
 console = Console(stderr=True)
 
 
+def _preprocess_fixture_argv(argv: list[str] | None = None) -> list[str]:
+    """Rewrite bare ``--fixture`` to ``--fixture=__CPA_FIXTURE_AUTO__``.
+
+    Typer/Click requires an option argument; Commander allows ``--fixture [dir]``.
+    This keeps CNA-compatible UX: ``--fixture`` alone enables auto-detect mode.
+    """
+    raw = list(sys.argv if argv is None else argv)
+    if not raw:
+        return raw
+    out = [raw[0]]
+    i = 1
+    while i < len(raw):
+        arg = raw[i]
+        if arg == "--fixture":
+            if i + 1 < len(raw) and not raw[i + 1].startswith("-"):
+                out.extend(["--fixture", raw[i + 1]])
+                i += 2
+            else:
+                out.append(f"--fixture={_FIXTURE_AUTO}")
+                i += 1
+            continue
+        out.append(arg)
+        i += 1
+    if argv is None:
+        sys.argv = out
+    return out
+
+
+def _expand_variadic_option(argv: list[str], option: str) -> list[str]:
+    """Expand ``--addons a b`` into ``--addons a --addons b`` (CNA Commander parity).
+
+    Typer's ``list[str]`` Option only accepts one value per flag. Commander uses
+    ``--addons [extensions...]``, so users naturally write space-separated lists.
+    """
+    out: list[str] = []
+    i = 0
+    prefix = option + "="
+    while i < len(argv):
+        arg = argv[i]
+        if arg == option:
+            i += 1
+            values: list[str] = []
+            while i < len(argv) and not argv[i].startswith("-"):
+                values.append(argv[i])
+                i += 1
+            if not values:
+                out.append(option)
+            else:
+                for value in values:
+                    out.extend([option, value])
+            continue
+        if arg.startswith(prefix):
+            value = arg[len(prefix) :]
+            out.extend([option, value] if value else [option])
+            i += 1
+            continue
+        out.append(arg)
+        i += 1
+    return out
+
+
+def _preprocess_cli_argv(argv: list[str] | None = None) -> list[str]:
+    """Apply argv rewrites needed before Typer parses the CLI."""
+    out = _preprocess_fixture_argv(argv)
+    out = _expand_variadic_option(out, "--addons")
+    out = _expand_variadic_option(out, "--extend")
+    if argv is None:
+        sys.argv = out
+    return out
+
+
+def apply_fixture_mode(fixture: str | None) -> None:
+    """Translate ``--fixture`` into ``CPA_CATALOG_FIXTURE`` / ``CPA_FIXTURE_DIR``."""
+    if fixture is None and os.environ.get("CPA_CATALOG_FIXTURE") != "1":
+        return
+    os.environ["CPA_CATALOG_FIXTURE"] = "1"
+    if fixture is not None and fixture != _FIXTURE_AUTO and fixture != "":
+        os.environ["CPA_FIXTURE_DIR"] = fixture
+
+
 def _in_ci() -> bool:
     return os.environ.get("CI", "").lower() in {"1", "true", "yes"}
 
@@ -159,9 +246,8 @@ def main() -> None:
     `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")
+    _preprocess_cli_argv()
     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")
@@ -169,9 +255,8 @@ def main() -> None:
     app()
 
 
-@app.callback(invoke_without_command=True)
+@app.command(name="create-awesome-python-app")
 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"),
@@ -192,14 +277,25 @@ def scaffold(
     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"),
+    fixture: str | None = typer.Option(
+        None,
+        "--fixture",
+        help=(
+            "Load the template catalog from the local fixtures/ directory "
+            "instead of the network (optional DIR = repo root; also "
+            "CPA_FIXTURE_DIR / CPA_CATALOG_FIXTURE)"
+        ),
+    ),
 ) -> None:
     if version:
         console.print(__version__)
         raise typer.Exit(0)
     if info:
         print_env_info()
-    if ctx.invoked_subcommand is not None:
-        return
+
+    # Translate --fixture into env vars before catalog loads
+    # (--list-templates / interactive / scaffold).
+    apply_fixture_mode(fixture)
 
     if list_templates or list_addons:
         from create_awesome_python_app.catalog import list_addons as la
@@ -315,12 +411,22 @@ def scaffold(
             extension_choices = build_extension_choices(interactive_catalog, template)
             grouped_extensions = group_extension_choices(extension_choices)
             if grouped_extensions:
+                from create_awesome_python_app.catalog import (
+                    CategoryInfo,
+                    category_index,
+                    format_category_choice_title,
+                )
+
+                categories = category_index(interactive_catalog)
                 category_choices = [
                     Choice(
-                        title=(
-                            f"{choices[0].category_name} "
-                            f"({len(choices)} extension"
-                            f"{'s' if len(choices) != 1 else ''})"
+                        title=format_category_choice_title(
+                            categories.get(category_slug)
+                            or CategoryInfo(
+                                slug=category_slug,
+                                name=choices[0].category_name,
+                            ),
+                            len(choices),
                         ),
                         value=category_slug,
                     )
@@ -444,8 +550,29 @@ def cache_dir_cmd() -> None:
     console.print(str(default_cache_dir()))
 
 
+def _cache_json_print(payload: Any) -> None:
+    """Print machine-readable JSON to stdout (not the stderr console)."""
+    import json
+    from dataclasses import asdict, is_dataclass
+
+    def _to_jsonable(value: Any) -> Any:
+        if isinstance(value, Path):
+            return str(value)
+        if is_dataclass(value) and not isinstance(value, type):
+            return {k: _to_jsonable(v) for k, v in asdict(value).items()}
+        if isinstance(value, list):
+            return [_to_jsonable(item) for item in value]
+        if isinstance(value, dict):
+            return {k: _to_jsonable(v) for k, v in value.items()}
+        return value
+
+    typer.echo(json.dumps(_to_jsonable(payload), indent=2))
+
+
 @cache_app.command("list")
-def cache_list_cmd() -> None:
+def cache_list_cmd(
+    json_out: bool = typer.Option(False, "--json", help="Output as JSON"),
+) -> None:
     from create_awesome_python_app.cache import (
         format_age,
         format_bytes,
@@ -454,6 +581,9 @@ def cache_list_cmd() -> None:
     )
 
     entries = list_cache_entries()
+    if json_out:
+        _cache_json_print(entries)
+        return
     if not entries:
         console.print("[dim]No cached templates or extensions.[/dim]")
         console.print(
@@ -488,10 +618,38 @@ def cache_list_cmd() -> None:
 def cache_clean_cmd(
     id: str | None = typer.Argument(None),
     catalog: bool = typer.Option(False, "--catalog"),
+    json_out: bool = typer.Option(False, "--json", help="Output as JSON"),
+    force: bool = typer.Option(
+        False, "--force", "-f", help="Skip interactive confirmation"
+    ),
 ) -> None:
     from create_awesome_python_app.cache import clean_cache
 
+    # Targeted cleans (id / --catalog) never prompt.
+    if not catalog and id is None and not json_out and not force:
+        if not sys.stdin.isatty():
+            console.print(
+                "[yellow]Non-interactive shell — use --json or --force to skip "
+                "the prompt, or specify an id to target a specific entry.[/yellow]"
+            )
+            return
+        import questionary
+
+        from create_awesome_python_app.prompt_style import CPA_PROMPT_STYLE
+
+        confirmed = questionary.confirm(
+            "Remove ALL cached templates and extensions?",
+            default=False,
+            style=CPA_PROMPT_STYLE,
+        ).ask()
+        if not confirmed:
+            console.print("[dim]Clean cancelled.[/dim]")
+            return
+
     result = clean_cache(id, catalog=catalog)
+    if json_out:
+        _cache_json_print(result)
+        return
     if result.not_found:
         console.print(f"[yellow]No cache entry found for id: {id}[/yellow]")
         return
@@ -503,10 +661,18 @@ def cache_clean_cmd(
 
 
 @cache_app.command("verify")
-def cache_verify_cmd(id: str | None = typer.Argument(None)) -> None:
+def cache_verify_cmd(
+    id: str | None = typer.Argument(None),
+    json_out: bool = typer.Option(False, "--json", help="Output as JSON"),
+) -> None:
     from create_awesome_python_app.cache import verify_cache
 
     results = verify_cache(id)
+    if json_out:
+        _cache_json_print(results)
+        if any(not bool(entry.fsck_ok) for entry in results):
+            raise typer.Exit(1)
+        raise typer.Exit(0)
     if not results:
         console.print("[dim]No cached entries.[/dim]")
         raise typer.Exit(0)
@@ -527,10 +693,15 @@ def cache_verify_cmd(id: str | None = typer.Argument(None)) -> None:
 
 
 @cache_app.command("outdated")
-def cache_outdated_cmd() -> None:
+def cache_outdated_cmd(
+    json_out: bool = typer.Option(False, "--json", help="Output as JSON"),
+) -> None:
     from create_awesome_python_app.cache import check_outdated
 
     results = check_outdated()
+    if json_out:
+        _cache_json_print(results)
+        return
     if not results:
         console.print("[dim]No cached entries to check.[/dim]")
         return
@@ -590,10 +761,17 @@ def cache_update_cmd(id: str | None = typer.Argument(None)) -> None:
 
 
 @cache_app.command("doctor")
-def cache_doctor_cmd() -> None:
+def cache_doctor_cmd(
+    json_out: bool = typer.Option(False, "--json", help="Output as JSON"),
+) -> None:
     from create_awesome_python_app.cache import run_doctor
 
     results = run_doctor()
+    if json_out:
+        _cache_json_print(results)
+        if any(not row.ok for row in results):
+            raise typer.Exit(1)
+        raise typer.Exit(0)
     all_ok = True
     for row in results:
         mark = "[green]✓[/green]" if row.ok else "[red]✗[/red]"

{create_awesome_python_app-0.2.6.dist-info → create_awesome_python_app-0.2.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: create-awesome-python-app
-Version: 0.2.6
+Version: 0.2.8
 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
@@ -42,6 +42,7 @@ From blank folder to a working FastAPI, Django, Celery, CLI, or uv workspace pro
 [![MegaLinter][megalinterbadge]][megalinterurl]
 [![Shellcheck][shellcheckbadge]][shellcheckurl]
 [![Commit Activity][commitactivitybadge]][commitactivityurl]
+[![Discord](https://img.shields.io/discord/1527933660764831825?label=Discord&logo=discord&logoColor=white)](https://discord.gg/dwFTsR7fK2)
 
 **[Official Site](https://create-awesome-python-app.vercel.app)** · [Templates](https://create-awesome-python-app.vercel.app/templates) · [Extensions](https://create-awesome-python-app.vercel.app/extensions) · [Docs](https://create-awesome-python-app.vercel.app/docs) · [GitHub](https://github.com/Create-Python-App/create-python-app) · [PyPI](https://pypi.org/project/create-awesome-python-app/)
 

create_awesome_python_app-0.2.8.dist-info/RECORD

@@ -0,0 +1,9 @@
+create_awesome_python_app/__init__.py,sha256=bpha_GXZNmruh0uP4KvEZzHYZOOzyqluLF2ediJjcdo,60
+create_awesome_python_app/cache.py,sha256=eHKUlunGexZKYJo0HDNoBoOVq0DjLyRYgEe_wUh4Fk0,11812
+create_awesome_python_app/catalog.py,sha256=ZB-ieyEn_TBqVBbCbFkK9h3VJoYtifvvOxs_BM2tDEw,22754
+create_awesome_python_app/cli.py,sha256=bSmivzm4lUOcDtoyNT-t3PL_Xb1O8msAUl_XFczeNkQ,27555
+create_awesome_python_app/prompt_style.py,sha256=pERX1qPQSLZXeJvPVFC7z85dvte73ZV4iuENPQduheE,3463
+create_awesome_python_app-0.2.8.dist-info/METADATA,sha256=YcMQFDgWXeK0jT77VqBV6LOYNBxfTWOhhYRWpZ1A9W0,23271
+create_awesome_python_app-0.2.8.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+create_awesome_python_app-0.2.8.dist-info/entry_points.txt,sha256=rszFbUjY-lvMDZ96zX1lALJwgD1mI3CkUuNyF2qqjYo,81
+create_awesome_python_app-0.2.8.dist-info/RECORD,,

create_awesome_python_app-0.2.6.dist-info/RECORD

@@ -1,9 +0,0 @@
-create_awesome_python_app/__init__.py,sha256=jCOrfI56gv-0n6QwEJfZ9bLqCHZ00wfNByGXx5mr5xM,60
-create_awesome_python_app/cache.py,sha256=eHKUlunGexZKYJo0HDNoBoOVq0DjLyRYgEe_wUh4Fk0,11812
-create_awesome_python_app/catalog.py,sha256=w5GS_kQ6MM37AilutXbYZ9Hk5JGa_12crzI0LYzKfRg,16821
-create_awesome_python_app/cli.py,sha256=6og82WI-RZxTqHETqrieA8relgppwCqFntOEmOFrIPk,21195
-create_awesome_python_app/prompt_style.py,sha256=pERX1qPQSLZXeJvPVFC7z85dvte73ZV4iuENPQduheE,3463
-create_awesome_python_app-0.2.6.dist-info/METADATA,sha256=aRJu55BsSSuTwcWZguOHt03n5RW6trGGhJ2pIu9vJiY,23132
-create_awesome_python_app-0.2.6.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
-create_awesome_python_app-0.2.6.dist-info/entry_points.txt,sha256=rszFbUjY-lvMDZ96zX1lALJwgD1mI3CkUuNyF2qqjYo,81
-create_awesome_python_app-0.2.6.dist-info/RECORD,,