splent-cli 1.53.0__tar.gz → 1.55.0__tar.gz

{splent_cli-1.53.0/src/splent_cli.egg-info → splent_cli-1.55.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: splent_cli
-Version: 1.53.0
+Version: 1.55.0
 Summary: SPLENT-CLI is a CLI to be able to work on your development more easily.
 Author-email: DiversoLab <diversolab@us.es>
 License-Expression: LGPL-3.0-or-later

{splent_cli-1.53.0 → splent_cli-1.55.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "splent_cli"
-version = "1.53.0"
+version = "1.55.0"
 description = "SPLENT-CLI is a CLI to be able to work on your development more easily."
 readme = "README.md"
 requires-python = ">=3.13"

{splent_cli-1.53.0 → splent_cli-1.55.0}/src/splent_cli/commands/command/command_create.py

@@ -10,7 +10,7 @@ from splent_cli.utils.path_utils import PathUtils
 # Segments separated by ':', each starting with a letter. Dashes are allowed
 # in the Click name (feature:inject-config) and become '_' in the file name
 # and the Python identifier.
-_NAME_RE = re.compile(r"[a-z][a-z0-9_-]*(:[a-z][a-z0-9_-]*)*")
+_NAME_RE = re.compile(r"[a-z][a-z0-9_-]*(:[a-z][a-z0-9_-]*)?")
 
 # Names the generated module already uses; a command function with one of
 # these names would shadow the import it relies on.
@@ -33,7 +33,7 @@ def _validate_name(name: str) -> tuple[str, str]:
     ):
         raise click.ClickException(
             f"Invalid command name '{name}'. Use lowercase letters, digits, "
-            "'_' and '-', starting with a letter, with ':' between segments "
+            "'_' and '-', starting with a letter, and at most one ':' "
             "(for example db:dump-all). Python keywords and the names click, "
             "current_app and requires_app are not allowed."
         )

{splent_cli-1.53.0 → splent_cli-1.55.0}/src/splent_cli/commands/feature/feature_frontend_init.py

@@ -1,5 +1,5 @@
 """
-splent feature:frontend:init
+splent feature:frontend-init
 
 Move a feature to frontend/ (SD-01): its bundle is then built by the SPLENT
 toolchain from frontend/package.json, against the feature's own
@@ -17,6 +17,7 @@ from splent_cli.services import frontend
 from splent_cli.commands.feature.feature_npm import editable_frontend_root
 from splent_cli.utils.io_utils import load_toml
 from splent_cli.utils.template_drift import feature_ctx, render_template
+from splent_cli.utils.command_loader import old_name
 
 # The SPLENT-owned files of a feature with frontend/, written as
 # feature:sync-template would write them.
@@ -176,7 +177,7 @@ def _leftovers(
 
 
 @click.command(
-    "feature:frontend:init",
+    "feature:frontend-init",
     short_help="Give a feature a frontend/ of its own, built by the SPLENT toolchain.",
 )
 @click.argument("feature_ref")
@@ -208,8 +209,8 @@ def feature_frontend_init(feature_ref, adopt_vendor):
 
     \b
     Examples:
-      splent feature:frontend:init charts
-      splent feature:frontend:init charts --adopt-vendor
+      splent feature:frontend-init charts
+      splent feature:frontend-init charts --adopt-vendor
     """
     root, name = editable_frontend_root(feature_ref)
     if frontend.declares(root):
@@ -247,7 +248,7 @@ def feature_frontend_init(feature_ref, adopt_vendor):
     if fallback:
         (root / "frontend" / "webpack.extra.js").write_text(
             "// What the feature's webpack.config.js set beyond the SPLENT preset,\n"
-            "// merged over it (feature:frontend:init carried it over).\n"
+            "// merged over it (feature:frontend-init carried it over).\n"
             "module.exports = {\n"
             f"  resolve: {{ fallback: {json.dumps(fallback)} }},\n"
             "};\n",
@@ -308,4 +309,7 @@ def feature_frontend_init(feature_ref, adopt_vendor):
     click.echo()
 
 
-cli_command = feature_frontend_init
+cli_commands = [
+    feature_frontend_init,
+    old_name("feature:frontend:init", feature_frontend_init),
+]

{splent_cli-1.53.0 → splent_cli-1.55.0}/src/splent_cli/commands/feature/feature_hook_add.py

@@ -1,5 +1,5 @@
 """
-splent feature:hook:add
+splent feature:hook-add
 
 Add a new template hook registration to a feature's hooks.py.
 Also updates [tool.splent.contract.provides].hooks in pyproject.toml.
@@ -17,13 +17,14 @@ from pathlib import Path
 from splent_cli.services import context
 from splent_cli.utils.feature_utils import normalize_namespace
 from splent_cli.utils.io_utils import atomic_write
+from splent_cli.utils.command_loader import old_name
 
 
 DEFAULT_NAMESPACE = os.getenv("SPLENT_DEFAULT_NAMESPACE", "splent_io")
 
 
 # ─────────────────────────────────────────────────────────────────────────────
-# Helpers (shared with feature:hook:remove)
+# Helpers (shared with feature:hook-remove)
 # ─────────────────────────────────────────────────────────────────────────────
 
 
@@ -317,7 +318,7 @@ def _check_function_name(function_name: str) -> None:
 
 
 @click.command(
-    "feature:hook:add",
+    "feature:hook-add",
     short_help="Add a new template hook to a feature's hooks.py.",
 )
 @click.argument("feature_ref")
@@ -342,14 +343,14 @@ def feature_hook_add(feature_ref, slot, function_name):
 
     \b
     Example:
-      splent feature:hook:add splent_feature_notes layout.sidebar render_notes_sidebar
+      splent feature:hook-add splent_feature_notes layout.sidebar render_notes_sidebar
     """
     _check_slot(slot)
     _check_function_name(function_name)
 
     workspace = str(context.workspace())
     feature_path, ns, name = resolve_editable(
-        feature_ref, workspace, "feature:hook:add"
+        feature_ref, workspace, "feature:hook-add"
     )
 
     package_dir = feature_path / "src" / ns / name
@@ -403,4 +404,4 @@ def feature_hook_add(feature_ref, slot, function_name):
     click.echo()
 
 
-cli_command = feature_hook_add
+cli_commands = [feature_hook_add, old_name("feature:hook:add", feature_hook_add)]

{splent_cli-1.53.0 → splent_cli-1.55.0}/src/splent_cli/commands/feature/feature_hook_remove.py

@@ -1,5 +1,5 @@
 """
-splent feature:hook:remove
+splent feature:hook-remove
 
 Remove a template hook registration from a feature's hooks.py.
 Optionally also removes the callback function definition.
@@ -17,6 +17,7 @@ from splent_cli.commands.feature.feature_hook_add import (
     rewrite_provides_hooks,
 )
 from splent_cli.utils.io_utils import atomic_write
+from splent_cli.utils.command_loader import old_name
 
 
 # ─────────────────────────────────────────────────────────────────────────────
@@ -90,7 +91,7 @@ def _remove_trailing_blank_lines(text: str) -> str:
 
 
 @click.command(
-    "feature:hook:remove",
+    "feature:hook-remove",
     short_help="Remove a template hook from a feature's hooks.py.",
 )
 @click.argument("feature_ref")
@@ -116,12 +117,12 @@ def feature_hook_remove(feature_ref, slot, with_function, yes):
 
     \b
     Example:
-      splent feature:hook:remove splent_feature_notes layout.sidebar
-      splent feature:hook:remove splent_feature_notes layout.sidebar --with-function -y
+      splent feature:hook-remove splent_feature_notes layout.sidebar
+      splent feature:hook-remove splent_feature_notes layout.sidebar --with-function -y
     """
     workspace = str(context.workspace())
     feature_path, ns, name = resolve_editable(
-        feature_ref, workspace, "feature:hook:remove"
+        feature_ref, workspace, "feature:hook-remove"
     )
 
     hooks_path = feature_path / "src" / ns / name / "hooks.py"
@@ -185,4 +186,7 @@ def feature_hook_remove(feature_ref, slot, with_function, yes):
     click.echo()
 
 
-cli_command = feature_hook_remove
+cli_commands = [
+    feature_hook_remove,
+    old_name("feature:hook:remove", feature_hook_remove),
+]

{splent_cli-1.53.0 → splent_cli-1.55.0}/src/splent_cli/commands/feature/feature_hooks.py

@@ -138,7 +138,7 @@ def feature_hooks(feature_ref, as_json):
     click.echo()
     click.echo(
         click.style("  Manage hooks with:", fg="bright_black")
-        + f"  splent feature:hook:add {name} <slot> <function>"
+        + f"  splent feature:hook-add {name} <slot> <function>"
     )
     click.echo()
 

{splent_cli-1.53.0 → splent_cli-1.55.0}/src/splent_cli/commands/feature/feature_npm.py

@@ -68,7 +68,7 @@ def feature_npm(feature_ref, npm_args):
     if not frontend.declares(root):
         raise click.ClickException(
             f"{name} has no frontend/package.json. Create it with "
-            f"splent feature:frontend:init {name}."
+            f"splent feature:frontend-init {name}."
         )
     args = [*npm_args, "--ignore-scripts"]
     if npm_args[0] in _SAVING:

{splent_cli-1.53.0 → splent_cli-1.55.0}/src/splent_cli/commands/feature/feature_pip_install.py

@@ -15,6 +15,13 @@ and because a private feature may deliberately never be published there.
 Without the fallback, one unpublished feature makes the whole product
 unbuildable even though its code is tagged and reachable.
 
+Everything is installed by one pip run. Which channel serves each feature is
+settled first, asking PyPI and the forge for all of them at once, and a tag is
+named by the commit it points at: pip keeps the wheel it builds from a commit
+in its cache, and the next build takes it from there instead of cloning and
+building the feature again. Only when that run fails are the features
+installed one at a time, which says which one failed and why.
+
 Three things about this are worth stating plainly rather than discovering:
 
   * only [tool.splent].features is read. features_dev and features_prod are
@@ -39,7 +46,9 @@ Example:
 """
 
 import os
+import subprocess
 import sys
+from concurrent.futures import ThreadPoolExecutor
 
 import click
 import tomllib
@@ -154,6 +163,180 @@ def _last_line(output: str) -> str:
     return _redacted(lines[-1]) if lines else "no output"
 
 
+# How many PyPI and forge questions are asked at once.
+PROBE_WORKERS = 16
+
+# Seconds one question to PyPI or one ``git ls-remote`` may take.
+PROBE_TIMEOUT = 20
+
+# What a failed pip run is summed up with, counted from its end.
+TAIL_LINES = 15
+
+
+def _asks_pypi() -> bool:
+    """Whether pip installs from PyPI, so PyPI is the one to ask.
+
+    A PIP_INDEX_URL that points elsewhere (a mirror, a private index) serves
+    what PyPI does not say, so nothing is asked and the features are
+    installed one at a time, each trying its index first.
+    """
+    index = os.getenv("PIP_INDEX_URL", "").strip()
+    return not index or index.rstrip("/") in (
+        "https://pypi.org/simple",
+        "https://pypi.python.org/simple",
+    )
+
+
+def _pypi_serves(dist: str, version: str) -> bool | None:
+    """Whether PyPI serves ``dist==version``, None when it could not be asked."""
+    import requests
+
+    url = f"https://pypi.org/pypi/{dist}/{version}/json"
+    for _attempt in range(2):
+        try:
+            response = requests.get(url, timeout=PROBE_TIMEOUT)
+        except requests.RequestException:
+            continue
+        if response.status_code == 200:
+            return True
+        if response.status_code == 404:
+            return False
+    return None
+
+
+def _tag_commit(namespace: str, name: str, ref: str) -> tuple[str, str, str] | None:
+    """(real_url, display_url, commit) of the tag, from the first spelling of
+    the namespace that has it, or None.
+
+    Asked with ``git ls-remote``, so nothing is cloned. An annotated tag is
+    named by the commit it points at, not by the tag object.
+    """
+    env = {
+        **os.environ,
+        **forge.git_auth_env(),
+        "GIT_TERMINAL_PROMPT": "0",
+        "LC_ALL": "C",
+    }
+    for spelling in namespace_spellings(namespace):
+        real, display = https_url(spelling, name)
+        try:
+            result = subprocess.run(
+                ["git", "ls-remote", real, f"refs/tags/{ref}", f"refs/tags/{ref}^{{}}"],
+                capture_output=True,
+                text=True,
+                timeout=PROBE_TIMEOUT,
+                env=env,
+            )
+        except (OSError, subprocess.TimeoutExpired):
+            continue
+        if result.returncode != 0:
+            continue
+        refs = dict(
+            reversed(line.split("\t", 1))
+            for line in result.stdout.splitlines()
+            if "\t" in line
+        )
+        commit = refs.get(f"refs/tags/{ref}^{{}}") or refs.get(f"refs/tags/{ref}")
+        if commit:
+            return real, display, commit
+    return None
+
+
+def _pip_install_many(specs: list[str]) -> tuple[bool, str]:
+    """One pip run for every requirement in ``specs``.
+
+    What pip says is shown as it says it, redacted line by line, so a long
+    build is never silent. Returns whether it succeeded and its last lines.
+    """
+    auth = forge.git_auth_env()
+    cmd = [sys.executable, "-m", "pip", "install", "--progress-bar", "off", *specs]
+    tail: list[str] = []
+    try:
+        process = subprocess.Popen(
+            cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+            env={**os.environ, **auth} if auth else None,
+        )
+    except OSError as exc:
+        return False, str(exc)
+    assert process.stdout is not None
+    for line in process.stdout:
+        line = _redacted(line.rstrip("\n"))
+        click.echo(f"    {line}")
+        tail = [*tail, line][-TAIL_LINES:]
+    return process.wait() == 0, "\n".join(tail)
+
+
+def _requirement(entry, data, pypi_only, asks_pypi):
+    """What one pip run installs for ``entry``.
+
+    Returns (spec, display, from_git), or None when it cannot be settled
+    without trying (PyPI could not be asked, or its tag could not be found),
+    which leaves the entry to the one-at-a-time install.
+    """
+    namespace, name, version, ref = _parse_feature_entry(entry)
+    dist = feature_distribution(data, name)
+    if not version:
+        return dist, dist, None
+    spec = f"{dist}=={version}"
+    if pypi_only:
+        return spec, spec, None
+    if not (ref and namespace):
+        return spec, spec, None
+    if not asks_pypi:
+        return None
+    served = _pypi_serves(dist, version)
+    if served is None:
+        return None
+    if served:
+        return spec, spec, None
+    found = _tag_commit(namespace, name, ref)
+    if found is None:
+        return None
+    real, display, commit = found
+    return (
+        f"{dist} @ git+{real}@{commit}",
+        f"git+{display}@{ref} ({commit[:12]})",
+        f"{name} {ref}",
+    )
+
+
+def _install_together(features, data, pypi_only) -> list[str] | None:
+    """Install every feature in one pip run.
+
+    Returns what came from a git tag, or None when the features have to be
+    installed one at a time: one of them could not be settled in advance, or
+    the run failed and the one-at-a-time install says which feature broke it.
+    """
+    asks_pypi = _asks_pypi()
+    with ThreadPoolExecutor(max_workers=PROBE_WORKERS) as pool:
+        plan = list(
+            pool.map(
+                lambda entry: _requirement(entry, data, pypi_only, asks_pypi),
+                features,
+            )
+        )
+    if any(item is None for item in plan):
+        return None
+
+    for _spec, display, from_git in plan:
+        click.echo(f"  {'git ' if from_git else 'pypi'}  {display}")
+    click.echo()
+    ok, tail = _pip_install_many([spec for spec, _display, _git in plan])
+    click.echo()
+    if not ok:
+        click.secho(
+            "  Installing them together failed. Installing them one at a time, "
+            "to say which one:",
+            fg="yellow",
+        )
+        click.echo()
+        return None
+    return [from_git for _spec, _display, from_git in plan if from_git]
+
+
 @click.command(
     "feature:pip-install",
     short_help="Install the declared features from PyPI, or from their git tag.",
@@ -204,15 +387,22 @@ def feature_pip_install(pypi_only):
 
     click.echo(f"  Installing {len(features)} feature(s)...\n")
 
+    unpinned = [
+        _parse_feature_entry(entry)[1]
+        for entry in features
+        if not _parse_feature_entry(entry)[2]
+    ]
+    together = _install_together(features, data, pypi_only)
+    if together is not None:
+        _summary(features, unpinned, together, [])
+        return
+
     failed = []
-    unpinned = []
     from_git = []
     for entry in features:
         namespace, name, version, ref = _parse_feature_entry(entry)
         dist = feature_distribution(data, name)
         spec = f"{dist}=={version}" if version else dist
-        if not version:
-            unpinned.append(name)
 
         click.echo(f"  installing {spec}")
 
@@ -250,6 +440,11 @@ def feature_pip_install(pypi_only):
             )
             failed.append(spec)
 
+    _summary(features, unpinned, from_git, failed)
+
+
+def _summary(features, unpinned, from_git, failed) -> None:
+    """What was installed from where, and what failed (which exits 1)."""
     click.echo()
     if unpinned:
         click.secho(

{splent_cli-1.53.0 → splent_cli-1.55.0}/src/splent_cli/commands/product/product_commands.py

@@ -80,7 +80,7 @@ def product_commands():
     own = _own_commands()
     product = context.active_app() or "product"
 
-    if not registry and not own.commands and not own.shadowed and not own.error:
+    if not (registry or own.commands or own.shadowed or own.refused or own.error):
         click.echo()
         click.secho("  No feature or product commands registered.", fg="yellow")
         click.echo()
@@ -108,6 +108,12 @@ def product_commands():
         _table("Product Commands", "Product", own_rows)
         click.echo()
         click.secho(f"  {len(own_rows)} command(s) of {product}'s own.", dim=True)
+    for name in own.refused:
+        click.secho(
+            f"  ⚠ {product} has a command {name}, which cannot be reached: a "
+            "command's name has one colon. Use a hyphen.",
+            fg="yellow",
+        )
     for name in own.shadowed:
         click.secho(
             f"  ⚠ {product} has a command {name}, which is the CLI's own and "

{splent_cli-1.53.0 → splent_cli-1.55.0}/src/splent_cli/commands/product/product_frontend_audit.py

@@ -1,5 +1,5 @@
 """
-product:frontend:audit — what the product's bundles ship, audited as one set.
+product:frontend-audit — what the product's bundles ship, audited as one set.
 
 Each feature with frontend/ audits its own lock when it is released (npm
 audit, services/frontend.py), but a bundle is immutable: an advisory
@@ -28,6 +28,7 @@ import click
 from splent_cli.services import compose, context, frontend
 from splent_cli.utils.frontend_check import LOCK_FILE, read_lock
 from splent_cli.utils.npm_semver import satisfies
+from splent_cli.utils.command_loader import old_name
 
 DEFAULT_REGISTRY = "https://registry.npmjs.org"
 ADVISORIES = "/-/npm/v1/security/advisories/bulk"
@@ -206,7 +207,7 @@ def _vendored(workspace: str, feature: dict, name: str) -> list[dict]:
 
 
 @click.command(
-    "product:frontend:audit",
+    "product:frontend-audit",
     short_help="Audit what the product's bundles ship against npm's advisories.",
 )
 @click.option(
@@ -234,8 +235,8 @@ def product_frontend_audit(sbom_path):
 
     \b
     Examples:
-      splent product:frontend:audit
-      splent product:frontend:audit --sbom frontend.sbom.cdx.json
+      splent product:frontend-audit
+      splent product:frontend-audit --sbom frontend.sbom.cdx.json
     """
     product = context.require_app()
     workspace = str(context.workspace())
@@ -320,4 +321,7 @@ def _product_version(product_dir: str) -> str:
     return str(data.get("project", {}).get("version") or "unknown")
 
 
-cli_command = product_frontend_audit
+cli_commands = [
+    product_frontend_audit,
+    old_name("product:frontend:audit", product_frontend_audit),
+]

{splent_cli-1.53.0 → splent_cli-1.55.0}/src/splent_cli/commands/product/product_test.py

@@ -27,7 +27,7 @@ from pathlib import Path
 
 import click
 
-from splent_cli.services import context, web_container
+from splent_cli.services import context, ui_audit, web_container
 from splent_cli.utils.feature_utils import (
     load_product_features,
     load_product_pyproject,
@@ -131,30 +131,34 @@ def _run_product_tests(product, workspace, levels, verbose):
 
         rc = run(cmd, check=False, env=env_vars).returncode
 
-    if not own:
-        return rc
-
     if levels:
         # A level flag asks for a quick, partial run. The product's tests
         # build its whole app and are not split by level, so they wait for
         # a full run, which is the one the release checks and the CI make.
+        if own:
+            click.secho(
+                f"\n  {product}'s own tests ({OWN_TESTS_DIR}/) run only without a "
+                "level flag.",
+                dim=True,
+            )
+        return rc
+
+    if own:
         click.secho(
-            f"\n  {product}'s own tests ({OWN_TESTS_DIR}/) run only without a "
-            "level flag.",
-            dim=True,
+            f"\n  ▶  {product}  its own tests ({len(own)} file(s) in {OWN_TESTS_DIR}/)",
+            fg="cyan",
+            bold=True,
         )
-        return rc
+        cmd = [sys.executable, "-m", "splent_cli", "product:test", "--own-tests"]
+        if verbose:
+            cmd.append("-v")
+        rc = run(cmd, check=False, env=env_vars).returncode or rc
 
-    click.secho(
-        f"\n  ▶  {product}  its own tests ({len(own)} file(s) in {OWN_TESTS_DIR}/)",
-        fg="cyan",
-        bold=True,
-    )
-    cmd = [sys.executable, "-m", "splent_cli", "product:test", "--own-tests"]
-    if verbose:
-        cmd.append("-v")
-    own_rc = run(cmd, check=False, env=env_vars).returncode
-    return rc or own_rc
+    # The look of its pages, when the product asks for it and its stack is up.
+    if ui_audit.declared(product_path):
+        cmd = [sys.executable, "-m", "splent_cli", "product:ui-audit", "--if-up"]
+        rc = run(cmd, check=False, env=env_vars).returncode or rc
+    return rc
 
 
 def _run_own_tests(product, verbose) -> None: