create-awesome-python-app 0.2.2__tar.gz → 0.2.4__tar.gz

{create_awesome_python_app-0.2.2 → create_awesome_python_app-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: create-awesome-python-app
-Version: 0.2.2
+Version: 0.2.4
 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
@@ -8,7 +8,7 @@ Project-URL: Issues, https://github.com/Create-Python-App/create-python-app/issu
 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.2.2
+Requires-Dist: create-python-app-core>=0.2.4
 Requires-Dist: questionary>=2.1.1
 Requires-Dist: rich>=15.0.0
 Requires-Dist: typer>=0.27.0

{create_awesome_python_app-0.2.2 → create_awesome_python_app-0.2.4}/pyproject.toml

@@ -1,12 +1,12 @@
 [project]
 name = "create-awesome-python-app"
-version = "0.2.2"
+version = "0.2.4"
 description = "Composable scaffolding CLI for production-ready Python apps"
 readme = "README.md"
 requires-python = ">=3.12"
 license = "MIT"
 dependencies = [
-    "create-python-app-core>=0.2.2",
+    "create-python-app-core>=0.2.4",
     "questionary>=2.1.1",
     "rich>=15.0.0",
     "typer>=0.27.0",

{create_awesome_python_app-0.2.2 → create_awesome_python_app-0.2.4}/src/create_awesome_python_app/__init__.py

@@ -1,3 +1,3 @@
 """Create Awesome Python App CLI."""
 
-__version__ = "0.2.2"
+__version__ = "0.2.4"

{create_awesome_python_app-0.2.2 → create_awesome_python_app-0.2.4}/src/create_awesome_python_app/catalog.py

@@ -16,6 +16,10 @@ 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 (
+    custom_template_title,
+    template_title_tokens,
+)
 
 console = Console(stderr=True)
 
@@ -26,7 +30,7 @@ CUSTOM_TEMPLATE_SENTINEL = "__custom_template__"
 class TemplateChoice:
     """Searchable interactive template choice."""
 
-    title: str
+    title: Any
     value: str
     search: str
 
@@ -235,32 +239,40 @@ def build_template_choices(data: dict[str, Any]) -> list[TemplateChoice]:
         category_name = categories.get(category_slug, category_slug)
         badge = short_category_label(category_name).ljust(10)[:10]
         slug = str(template.get("slug", ""))
-        labels = template.get("labels", [])
-        label_suffix = ""
-        if isinstance(labels, list) and labels:
-            label_suffix = " · " + ", ".join(str(label) for label in labels[:3])
+        labels_raw = template.get("labels", [])
+        labels = (
+            [str(label) for label in labels_raw[:3]]
+            if isinstance(labels_raw, list)
+            else []
+        )
         description = str(template.get("description", "")).strip()
-        description_suffix = f" — {description}" if description else ""
-        # Plain text only: questionary.autocomplete wraps choices in HTML for
-        # match highlighting, so ANSI / markup here raises XML parse errors.
-        title = (
-            f"{badge}  "
-            f"{template.get('name', slug)} ({slug})"
-            f"{label_suffix}{description_suffix}"
+        name = str(template.get("name", slug))
+        search = _search_text(template, category_name)
+        # FormattedText tokens (not raw ANSI): select() prints str titles
+        # literally, which showed ^[[1;94m… in terminals.
+        title = template_title_tokens(
+            category_slug=category_slug,
+            badge=badge,
+            name=name,
+            slug=slug,
+            labels=labels,
+            description=description,
+            search=search,
         )
         choices.append(
             TemplateChoice(
                 title=title,
                 value=template_url,
-                search=_search_text(template, category_name),
+                search=search,
             )
         )
 
+    custom_search = "custom own template url github file"
     choices.append(
         TemplateChoice(
-            title=" " * 12 + "Use my own template URL",
+            title=custom_template_title(custom_search),
             value=CUSTOM_TEMPLATE_SENTINEL,
-            search="custom own template url github file",
+            search=custom_search,
         )
     )
     return choices

{create_awesome_python_app-0.2.2 → create_awesome_python_app-0.2.4}/src/create_awesome_python_app/cli.py

@@ -104,6 +104,8 @@ def _prompt_custom_options(
 ) -> dict[str, str]:
     import questionary
 
+    from create_awesome_python_app.prompt_style import CPA_PROMPT_STYLE
+
     source = resolve_source(template, cache_dir=cache_dir)
     root = download_repository(
         source,
@@ -138,9 +140,12 @@ def _prompt_custom_options(
             answer = questionary.confirm(
                 message,
                 default=initial.lower() in {"1", "true", "yes", "on"},
+                style=CPA_PROMPT_STYLE,
             ).ask()
         else:
-            answer = questionary.text(message, default=initial).ask()
+            answer = questionary.text(
+                message, default=initial, style=CPA_PROMPT_STYLE
+            ).ask()
         if answer is None:
             raise typer.Exit(1)
         answers[option.key] = _stringify_option_value(answer)
@@ -230,30 +235,38 @@ def scaffold(
     if want_interactive and not template:
         try:
             import questionary
+            from questionary import Choice
 
             from create_awesome_python_app.catalog import (
                 CUSTOM_TEMPLATE_SENTINEL,
                 build_template_choices,
                 get_catalog_data,
             )
+            from create_awesome_python_app.prompt_style import CPA_PROMPT_STYLE
 
             interactive_catalog = get_catalog_data()
             template_choices = build_template_choices(interactive_catalog)
-            choice_by_title = {
-                choice.title: choice.value for choice in template_choices
-            }
-            selected_title = questionary.autocomplete(
-                "Pick a template (type to search)",
-                choices=list(choice_by_title),
-                match_middle=True,
+            # select + type-to-filter: browseable list (CNA-style discovery)
+            # instead of autocomplete-only. use_jk_keys must be False with search.
+            selected_template = questionary.select(
+                "Pick a template",
+                choices=[
+                    Choice(title=choice.title, value=choice.value)
+                    for choice in template_choices
+                ],
                 qmark="?",
+                pointer="❯",
+                style=CPA_PROMPT_STYLE,
+                use_search_filter=True,
+                use_jk_keys=False,
+                instruction="(↑↓ browse · type to filter · Enter)",
             ).ask()
-            selected_template = choice_by_title.get(str(selected_title), selected_title)
             if selected_template == CUSTOM_TEMPLATE_SENTINEL:
                 selected_template = questionary.text(
                     "Template URL",
                     default="file://.",
                     validate=lambda value: bool(value) or "Template URL is required",
+                    style=CPA_PROMPT_STYLE,
                 ).ask()
             template = selected_template
             if not template:
@@ -296,6 +309,7 @@ def scaffold(
                 get_catalog_data,
                 group_extension_choices,
             )
+            from create_awesome_python_app.prompt_style import CPA_PROMPT_STYLE
 
             interactive_catalog = interactive_catalog or get_catalog_data()
             extension_choices = build_extension_choices(interactive_catalog, template)
@@ -316,7 +330,8 @@ def scaffold(
                     "Which kinds of extensions do you need?",
                     choices=category_choices,
                     qmark="?",
-                    pointer=">",
+                    pointer="❯",
+                    style=CPA_PROMPT_STYLE,
                 ).ask()
                 selected_addons: list[str] = []
                 for category_slug in selected_categories or []:
@@ -330,7 +345,8 @@ def scaffold(
                             for choice in choices
                         ],
                         qmark="?",
-                        pointer=">",
+                        pointer="❯",
+                        style=CPA_PROMPT_STYLE,
                     ).ask()
                     selected_addons.extend(str(item) for item in picked or [])
                 addons = selected_addons

create_awesome_python_app-0.2.4/src/create_awesome_python_app/prompt_style.py

@@ -0,0 +1,113 @@
+"""High-contrast questionary styles for CPA interactive prompts."""
+
+from __future__ import annotations
+
+import os
+from typing import Any
+
+from questionary import Style
+
+# Lighter brand blues/greens than docs hex so selected rows stay readable on
+# dark terminals (slate backgrounds common in Arch/Ghostty/Alacritty).
+CPA_PROMPT_STYLE = Style.from_dict(
+    {
+        "qmark": "fg:#60a5fa bold",
+        "question": "bold fg:#f8fafc",
+        "answer": "fg:#4ade80 bold",
+        "pointer": "fg:#60a5fa bold",
+        "highlighted": "fg:#0f172a bg:#60a5fa bold",
+        "selected": "fg:#4ade80 bold",
+        "separator": "fg:#94a3b8",
+        "instruction": "fg:#94a3b8",
+        "text": "fg:#e2e8f0",
+        "disabled": "fg:#64748b italic",
+        "checkbox": "fg:#60a5fa",
+        "checkbox-selected": "fg:#4ade80 bold",
+    }
+)
+
+# Bright prompt_toolkit style strings (not raw ANSI — select() prints str titles
+# literally, so escapes show as ^[[...m unless titles are FormattedText tokens).
+_CATEGORY_STYLES = (
+    "fg:#facc15 bold",  # yellow
+    "fg:#4ade80 bold",  # green
+    "fg:#22d3ee bold",  # cyan
+    "fg:#e879f9 bold",  # magenta
+    "fg:#60a5fa bold",  # blue
+)
+
+
+class SearchableFormattedText(list):
+    """FormattedText tokens with ``.lower()`` for questionary search filter.
+
+    ``select(use_search_filter=True)`` does ``needle in choice.title.lower()``.
+    A plain token list has no ``.lower()``; this keeps filter working while
+    titles render as styled FormattedText.
+    """
+
+    def __init__(self, tokens: list[tuple[str, str]], search: str) -> None:
+        super().__init__(tokens)
+        self._search = search
+
+    def lower(self) -> str:
+        return self._search.lower()
+
+
+def colors_enabled() -> bool:
+    return not os.environ.get("NO_COLOR")
+
+
+def category_style(slug: str) -> str:
+    idx = sum(ord(char) for char in slug) % len(_CATEGORY_STYLES)
+    return _CATEGORY_STYLES[idx]
+
+
+def plain_title_text(title: Any) -> str:
+    """Join FormattedText token text (or return a plain string title)."""
+    if isinstance(title, list):
+        return "".join(str(token[1]) for token in title)
+    return str(title)
+
+
+def template_title_tokens(
+    *,
+    category_slug: str,
+    badge: str,
+    name: str,
+    slug: str,
+    labels: list[str],
+    description: str,
+    search: str,
+) -> SearchableFormattedText | str:
+    """Build a select-safe title: FormattedText when colors on, else plain str."""
+    label_suffix = ""
+    if labels:
+        label_suffix = " · " + ", ".join(labels[:3])
+    description_suffix = f" — {description}" if description else ""
+    plain = f"{badge}  {name} ({slug}){label_suffix}{description_suffix}"
+
+    if not colors_enabled():
+        return plain
+
+    tokens: list[tuple[str, str]] = [
+        (category_style(category_slug), badge),
+        ("", "  "),
+        ("bold", name),
+        ("class:instruction", f" ({slug})"),
+    ]
+    if label_suffix:
+        tokens.append(("class:instruction", label_suffix))
+    if description_suffix:
+        tokens.append(("fg:#94a3b8", description_suffix))
+    return SearchableFormattedText(tokens, search=search or plain)
+
+
+def custom_template_title(search: str) -> SearchableFormattedText | str:
+    label = "Use my own template URL"
+    plain = " " * 12 + label
+    if not colors_enabled():
+        return plain
+    return SearchableFormattedText(
+        [("", " " * 12), ("italic fg:#94a3b8", label)],
+        search=search or plain,
+    )

{create_awesome_python_app-0.2.2 → create_awesome_python_app-0.2.4}/tests/test_catalog_resolve.py

@@ -17,6 +17,10 @@ from create_awesome_python_app.catalog import (
     short_category_label,
     validate_extension_compatibility,
 )
+from create_awesome_python_app.prompt_style import (
+    SearchableFormattedText,
+    plain_title_text,
+)
 
 SAMPLE_CATALOG = {
     "templates": [
@@ -99,20 +103,41 @@ def test_build_template_choices_are_searchable() -> None:
     choices = build_template_choices(catalog)
     first = choices[0]
     assert first.value == "file:///templates/fastapi"
-    assert "FastAPI Starter" in first.title
-    assert "OpenAPI" in first.title
-    assert "uv" in first.title
-    assert "\033" not in first.title
+    title_text = plain_title_text(first.title)
+    assert "FastAPI Starter" in title_text
+    assert "OpenAPI" in title_text
+    assert "uv" in title_text
     assert "openapi" in first.search
     assert "backend" in first.search
     assert "uv" in first.search
     assert choices[-1].value == CUSTOM_TEMPLATE_SENTINEL
 
 
-def test_template_choice_titles_are_html_safe_for_questionary() -> None:
-    """questionary.autocomplete formats choice text as HTML (match underline)."""
-    from prompt_toolkit.formatted_text import HTML
+def test_template_choice_titles_use_formatted_text(monkeypatch) -> None:
+    """select() needs FormattedText tokens; raw ANSI shows as ^[[…m."""
+    monkeypatch.delenv("NO_COLOR", raising=False)
+    catalog = {
+        "categories": [
+            {"slug": "backend-applications", "name": "Backend Applications"}
+        ],
+        "templates": [
+            {
+                "slug": "fastapi-starter",
+                "name": "FastAPI Starter",
+                "url": "file:///templates/fastapi",
+                "category": "backend-applications",
+            }
+        ],
+    }
+    title = build_template_choices(catalog)[0].title
+    assert isinstance(title, SearchableFormattedText)
+    assert "\033" not in plain_title_text(title)
+    assert "FastAPI Starter" in plain_title_text(title)
+    assert "fastapi" in title.lower()
 
+
+def test_template_choice_titles_respect_no_color(monkeypatch) -> None:
+    monkeypatch.setenv("NO_COLOR", "1")
     catalog = {
         "categories": [
             {"slug": "backend-applications", "name": "Backend Applications"}
@@ -121,16 +146,15 @@ def test_template_choice_titles_are_html_safe_for_questionary() -> None:
             {
                 "slug": "fastapi-starter",
                 "name": "FastAPI Starter",
-                "description": "Async API with OpenAPI docs",
                 "url": "file:///templates/fastapi",
                 "category": "backend-applications",
-                "labels": ["FastAPI"],
             }
         ],
     }
     title = build_template_choices(catalog)[0].title
-    # Must not raise "not well-formed (invalid token)" from ANSI escapes.
-    HTML("{}<b><u>{}</u></b>{}").format(title[:3], title[3:6], title[6:])
+    assert isinstance(title, str)
+    assert "\033" not in title
+    assert "FastAPI Starter" in title
 
 
 def test_build_extension_choices_filters_by_template_type() -> None:

{create_awesome_python_app-0.2.2 → create_awesome_python_app-0.2.4}/tests/test_interactive.py

@@ -28,10 +28,10 @@ def test_in_ci_env(monkeypatch) -> None:
     os.environ.pop("CI", None)
 
 
-def test_interactive_template_autocomplete_omits_pointer(
+def test_interactive_template_select_uses_search_filter(
     tmp_path: Path, monkeypatch
 ) -> None:
-    """questionary.autocomplete rejects ``pointer`` (PromptSession TypeError)."""
+    """Template pick is a browsable select with type-to-filter (not autocomplete)."""
     template_dir = tmp_path / "fastapi"
     template_dir.mkdir()
     (template_dir / "cpa.config.json").write_text(
@@ -60,11 +60,9 @@ def test_interactive_template_autocomplete_omits_pointer(
 
     captured_kwargs: dict[str, object] = {}
 
-    def fake_autocomplete(*_args, **kwargs):
+    def fake_select(*_args, **kwargs):
         captured_kwargs.update(kwargs)
-        choices = kwargs.get("choices") or []
-        # Return a mapped title so choice_by_title resolves to the template URL.
-        return FakePrompt(choices[0] if choices else template_url)
+        return FakePrompt(template_url)
 
     def fake_checkbox(*_args, **_kwargs):
         return FakePrompt([])
@@ -75,7 +73,7 @@ def test_interactive_template_autocomplete_omits_pointer(
         captured["project_directory"] = project_directory
         captured["options"] = options
 
-    monkeypatch.setattr("questionary.autocomplete", fake_autocomplete)
+    monkeypatch.setattr("questionary.select", fake_select)
     monkeypatch.setattr("questionary.checkbox", fake_checkbox)
     monkeypatch.setattr(
         "create_awesome_python_app.cli.create_python_app",
@@ -89,7 +87,9 @@ def test_interactive_template_autocomplete_omits_pointer(
     result = runner.invoke(app, ["--interactive", "--no-install", "api"])
 
     assert result.exit_code == 0, result.stdout + result.stderr
-    assert "pointer" not in captured_kwargs
+    assert captured_kwargs.get("use_search_filter") is True
+    assert captured_kwargs.get("use_jk_keys") is False
+    assert captured_kwargs.get("style") is not None
     assert captured["project_directory"] == "api"