splent-cli 1.44.0__tar.gz → 1.46.0__tar.gz

{splent_cli-1.44.0/src/splent_cli.egg-info → splent_cli-1.46.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: splent_cli
-Version: 1.44.0
+Version: 1.46.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.44.0 → splent_cli-1.46.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "splent_cli"
-version = "1.44.0"
+version = "1.46.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.46.0/src/splent_cli/__init__.py

@@ -0,0 +1,42 @@
+"""The SPLENT command-line interface."""
+
+import os as _os
+from types import MappingProxyType as _MappingProxyType
+
+# What the operator actually exported, taken before anything reads a .env.
+#
+# This must stay the first thing the package does. cli.py runs load_dotenv(),
+# and so do framework modules it imports (path_utils, configuration), which
+# puts every workspace .env key into os.environ before any command runs. Read
+# afterwards, the shell and the file look identical: env:show could never say
+# "not loaded", env:list never showed "·", and the workspace .env passed for
+# shell values and beat the product's docker/.env. Compare against this
+# instead of os.environ whenever the question is "what did the shell export".
+SHELL_ENV = _MappingProxyType(dict(_os.environ))
+
+
+def _bytecode_away_from_the_working_copies() -> None:
+    """Write root's bytecode outside the workspace.
+
+    A ``docker exec`` into the CLI's container runs as root unless it says
+    ``-u``, and root's __pycache__ directories in the working copies of the
+    CLI, the framework and the features were the ones the owner's next
+    release could not rewrite. Root's go under /tmp instead; everyone else's
+    stay where Python puts them. A PYTHONPYCACHEPREFIX already set wins, and
+    so does a workspace root itself owns. What the CLI runs (pytest, the
+    release build) inherits it through the environment.
+    """
+    import sys
+
+    if sys.pycache_prefix or not hasattr(_os, "geteuid") or _os.geteuid() != 0:
+        return
+    try:
+        owner = _os.stat(_os.environ.get("WORKING_DIR") or "/workspace").st_uid
+    except OSError:
+        return
+    if owner != 0:
+        sys.pycache_prefix = "/tmp/splent-root-pycache"
+        _os.environ.setdefault("PYTHONPYCACHEPREFIX", sys.pycache_prefix)
+
+
+_bytecode_away_from_the_working_copies()

{splent_cli-1.44.0 → splent_cli-1.46.0}/src/splent_cli/cli.py

@@ -199,6 +199,12 @@ class SPLENTCLI(click.Group):
             from splent_cli.utils.dynamic_imports import get_app
             from splent_cli.utils.db_utils import check_db_connection
 
+            # The environment a command that boots the app builds it in when
+            # nothing says which (utils.decorators.boots_the_app).
+            boot_env = getattr(command, "boot_env", None)
+            if boot_env:
+                os.environ.setdefault("SPLENT_ENV", boot_env)
+
             # For another product than the selection the CLI's container stays
             # on the selection's network (compose.attach_self_to_network), so
             # what reaches this product's services runs where they are.

{splent_cli-1.44.0 → splent_cli-1.46.0}/src/splent_cli/commands/check/check_env.py

@@ -6,16 +6,18 @@ import os
 import sys
 
 import click
-import importlib.metadata
 
 from splent_cli.services import context
 from splent_cli.services.release_gate import pypi_credentials
 from splent_cli.utils import forge
+from splent_cli.utils.running_version import installed_version
 
 
 def _pkg_version(name: str) -> str | None:
+    # The checkout's version for an editable install, as `splent version`
+    # reports it: pip's metadata keeps the version it was installed at.
     try:
-        return importlib.metadata.version(name)
+        return installed_version(name)
     except Exception:
         return None
 

{splent_cli-1.44.0 → splent_cli-1.46.0}/src/splent_cli/commands/env/env_set.py

@@ -263,3 +263,9 @@ def run_wizard():
             break
         else:
             click.secho("Invalid option. Try again.", fg="red")
+
+
+# The group alone. The loader's fallback registers every command it finds in
+# a module, and found the subcommands too, so `splent forge`, `splent pypi`
+# and `splent github` existed as top-level copies of env:set's.
+cli_command = env_set_group

{splent_cli-1.44.0 → splent_cli-1.46.0}/src/splent_cli/commands/feature/feature_attach.py

@@ -3,6 +3,7 @@ import click
 from splent_cli.services import context, compose
 from splent_cli.utils.feature_utils import (
     drop_feature_entries,
+    entry_matches_feature,
     find_feature_entries,
     hot_reinstall,
     parse_feature_entry,
@@ -160,10 +161,35 @@ def feature_attach(feature_identifier, version, env_scope):
 
     attaching = sorted(declared) != sorted(wanted)
     if attaching:
-        drop_feature_entries(data, feature_name, namespace=namespace_fs)
+        # A list that declares the feature keeps it where it is, so a new pin
+        # does not move the entry away from its neighbours and its comment
+        # to the end of the list (uvlhub's, after each release --attach).
+        # Only a list it is new to gets it at the end, and the lists it
+        # leaves lose it.
+        keep_in_place: dict[str, int] = {}
+        for key, entry in declared:
+            if key in target_keys:
+                at = read_feature_list(data, key).index(entry)
+                keep_in_place[key] = min(at, keep_in_place.get(key, at))
+        drop_feature_entries(
+            data,
+            feature_name,
+            namespace=namespace_fs,
+            keys=tuple(key for key, _ in declared if key not in keep_in_place),
+        )
         for key in target_keys:
             features = read_feature_list(data, key)
-            features.append(full_name)
+            if key in keep_in_place:
+                features = [
+                    entry
+                    for entry in features
+                    if not entry_matches_feature(
+                        entry, feature_name, namespace=namespace_fs
+                    )
+                ]
+                features.insert(keep_in_place[key], full_name)
+            else:
+                features.append(full_name)
             write_features_to_data(data, features, key=key)
 
     # ── PyPI name, when it is not the feature's own ──────────────────

{splent_cli-1.44.0 → splent_cli-1.46.0}/src/splent_cli/commands/feature/feature_compat.py

@@ -259,14 +259,22 @@ def _parse_pyproject_entry(entry: str) -> tuple[str, str, str | None]:
     return ns, name, version or None
 
 
+def _product_reader(product_dir: str, pyproject_path: str | None = None):
+    """The reader of the product's pyproject.toml, or of PYPROJECT_PATH, a
+    candidate pyproject checked in its place (product:validate --pyproject)."""
+    from splent_framework.utils.pyproject_reader import PyprojectReader
+
+    if pyproject_path:
+        return PyprojectReader(pyproject_path)
+    return PyprojectReader.for_product(product_dir)
+
+
 def _resolve_all_product_features(
-    product_dir: str, workspace: str
+    product_dir: str, workspace: str, pyproject_path: str | None = None
 ) -> list[tuple[str, Path]]:
     """Read all features from the product and resolve to (label, path)."""
-    from splent_framework.utils.pyproject_reader import PyprojectReader
-
     try:
-        features_raw = PyprojectReader.for_product(product_dir).features
+        features_raw = _product_reader(product_dir, pyproject_path).features
     except FileNotFoundError:
         raise SystemExit("❌ pyproject.toml not found in product.")
 
@@ -435,7 +443,9 @@ def _contract_env(path: Path) -> str | None:
     return data.get("tool", {}).get("splent", {}).get("contract", {}).get("env")
 
 
-def env_scope_findings(workspace: str, product_dir: str) -> list[dict]:
+def env_scope_findings(
+    workspace: str, product_dir: str, pyproject_path: str | None = None
+) -> list[dict]:
     """Features confined to one environment, in a list that installs them in
     the other.
 
@@ -443,9 +453,7 @@ def env_scope_findings(workspace: str, product_dir: str) -> list[dict]:
     list the production image installed them too, phpMyAdmin with autologin
     to the database, and nothing said so.
     """
-    from splent_framework.utils.pyproject_reader import PyprojectReader
-
-    reader = PyprojectReader.for_product(product_dir)
+    reader = _product_reader(product_dir, pyproject_path)
     lists = {
         "features": reader.features,
         "features_dev": reader.features_dev,
@@ -501,7 +509,9 @@ def _joins_the_shared_network(compose_file: Path) -> bool:
     return "SPLENT_NETWORK" not in str(spec.get("name", ""))
 
 
-def network_findings(workspace: str, product_dir: str) -> list[dict]:
+def network_findings(
+    workspace: str, product_dir: str, pyproject_path: str | None = None
+) -> list[dict]:
     """Feature services the product cannot reach.
 
     Each product has a network of its own, and a feature's services join it
@@ -509,9 +519,7 @@ def network_findings(workspace: str, product_dir: str) -> list[dict]:
     instead, so the app could not send mail to Mailhog and phpMyAdmin could
     not reach the database, and nothing said why.
     """
-    from splent_framework.utils.pyproject_reader import PyprojectReader
-
-    reader = PyprojectReader.for_product(product_dir)
+    reader = _product_reader(product_dir, pyproject_path)
     findings = []
     for entry in reader.features + reader.features_dev + reader.features_prod:
         ns, name, version = _parse_pyproject_entry(entry)
@@ -537,14 +545,14 @@ def network_findings(workspace: str, product_dir: str) -> list[dict]:
     return findings
 
 
-def naming_findings(workspace: str, product_dir: str) -> list[dict]:
+def naming_findings(
+    workspace: str, product_dir: str, pyproject_path: str | None = None
+) -> list[dict]:
     """Features named after a product (auth_uvlhub). A warning, so the debt
     shows in every validation until the product drops them."""
-    from splent_framework.utils.pyproject_reader import PyprojectReader
-
     from splent_cli.utils.feature_naming import product_suffix, product_suffix_message
 
-    reader = PyprojectReader.for_product(product_dir)
+    reader = _product_reader(product_dir, pyproject_path)
     findings = []
     for entry in reader.features + reader.features_dev + reader.features_prod:
         _, name, _ = _parse_pyproject_entry(entry)
@@ -688,16 +696,14 @@ def version_floor_findings(labeled_paths: list[tuple[str, Path]]) -> list[dict]:
 
 
 def _environment_only_features(
-    product_dir: str, workspace: str, env: str | None
+    product_dir: str, workspace: str, env: str | None, pyproject_path: str | None = None
 ) -> list[tuple[str, Path]]:
     """The features ``features_<env>`` adds to the base list, resolved."""
-    from splent_framework.utils.pyproject_reader import PyprojectReader
-
     env = context.normalize_env(env)
     if not env:
         return []
     try:
-        reader = PyprojectReader.for_product(product_dir)
+        reader = _product_reader(product_dir, pyproject_path)
         base = set(reader.features)
         extra = [e for e in reader.features_for_env(env) if e not in base]
     except (FileNotFoundError, ValueError):
@@ -706,7 +712,10 @@ def _environment_only_features(
 
 
 def run_all_product_check(
-    workspace: str, product_dir: str, env: str | None = None
+    workspace: str,
+    product_dir: str,
+    env: str | None = None,
+    pyproject_path: str | None = None,
 ) -> list[dict]:
     """Run the full product compatibility check. Returns findings list.
 
@@ -714,9 +723,13 @@ def run_all_product_check(
     floors are checked across the features the product loads in ``env``
     (SPLENT_ENV when None, ``dev`` when that is unset too), base plus
     ``features_dev`` or ``features_prod``, the selection phase 1 checks.
+    ``pyproject_path`` names a candidate pyproject to read the features
+    from instead of the product's.
     """
     try:
-        labeled_paths = _resolve_all_product_features(product_dir, workspace)
+        labeled_paths = _resolve_all_product_features(
+            product_dir, workspace, pyproject_path
+        )
     except SystemExit:
         return []
     if not labeled_paths:
@@ -725,7 +738,8 @@ def run_all_product_check(
         env = os.getenv("SPLENT_ENV") or "dev"
     labeled_contracts = [(lbl, _read_contract(path)) for lbl, path in labeled_paths]
     findings = _analyse_all(labeled_contracts) + version_floor_findings(
-        labeled_paths + _environment_only_features(product_dir, workspace, env)
+        labeled_paths
+        + _environment_only_features(product_dir, workspace, env, pyproject_path)
     )
     return sorted(findings, key=lambda f: SEVERITY_ORDER[f["severity"]])
 

{splent_cli-1.44.0 → splent_cli-1.46.0}/src/splent_cli/commands/feature/feature_compile.py

@@ -6,7 +6,7 @@ import subprocess
 
 import click
 
-from splent_cli.services import compose, context
+from splent_cli.services import compose, context, frontend
 from splent_cli.utils.proc import run
 from splent_cli.utils.feature_utils import (
     get_features_from_pyproject,
@@ -196,17 +196,67 @@ def webpack_container(product: str, env: str, workspace: str) -> tuple[str | Non
     "assets/dist, and fail when the feature has nothing to build. "
     "feature:release runs it.",
 )
-def feature_compile(feature_name, watch, env_dev, env_prod, release_build):
+@click.option(
+    "--verify",
+    is_flag=True,
+    help="Build nothing: check that assets/meta/manifest.json matches the "
+    "files of assets/dist and the lock, for each feature with frontend/.",
+)
+def feature_compile(feature_name, watch, env_dev, env_prod, release_build, verify):
     if release_build and watch:
         raise click.UsageError("--release builds the bundle once; drop --watch.")
+    if verify and (watch or release_build):
+        raise click.UsageError("--verify builds nothing; drop --watch and --release.")
     production = (
         os.getenv("FLASK_ENV", "develop") == "production" or env_prod or release_build
     )
+    workspace = str(context.workspace())
 
-    features = (
-        [_feature_ref(feature_name)] if feature_name else get_features_from_pyproject()
-    )
+    # A feature with frontend/ of its own builds in the SPLENT toolchain and
+    # needs no product at all, so naming one is enough.
+    if feature_name and _frontend_root(workspace, _feature_ref(feature_name)):
+        features = [_feature_ref(feature_name)]
+    else:
+        features = (
+            [_feature_ref(feature_name)]
+            if feature_name
+            else get_features_from_pyproject()
+        )
+
+    if verify:
+        raise SystemExit(_verify_features(features, workspace))
+
+    frontend_features = [f for f in features if _frontend_root(workspace, f)]
+    legacy_features = [f for f in features if f not in frontend_features]
+    failed = [
+        feature
+        for feature in frontend_features
+        if not _compile_frontend(
+            _frontend_root(workspace, feature),
+            feature,
+            watch=watch,
+            production=production,
+            release_build=release_build,
+        )
+    ]
+
+    if legacy_features:
+        failed += _compile_legacy(
+            legacy_features, watch, production, env_dev, env_prod, release_build
+        )
+    if failed and not watch:
+        click.secho(
+            f"Compilation failed for {len(failed)} feature(s): {', '.join(failed)}",
+            fg="red",
+            err=True,
+        )
+        raise SystemExit(1)
 
+
+def _compile_legacy(features, watch, production, env_dev, env_prod, release_build):
+    """Compile features without frontend/ (legacy mode): their own
+    webpack.config.js, run in the product's web container against the
+    product's node_modules. The features that failed."""
     env = context.resolve_env(env_dev, env_prod)
     product = context.require_app()
     workspace = str(context.workspace())
@@ -218,7 +268,7 @@ def feature_compile(feature_name, watch, env_dev, env_prod, release_build):
     # Every feature is attempted, so one run reports every broken bundle, and
     # the exit code then says whether any failed: the production Dockerfile
     # chains `splent feature:compile && ...` and must stop on a failure.
-    failed = [
+    return [
         feature
         for feature in features
         if not _compile_in_container(
@@ -232,13 +282,124 @@ def feature_compile(feature_name, watch, env_dev, env_prod, release_build):
             release_build=release_build,
         )
     ]
-    if failed and not watch:
+
+
+def _split_ref(feature: str) -> tuple[str, str, str | None]:
+    """``(namespace, name, version)`` of a feature ref, splent_io by default."""
+    parts = feature.split("/")
+    if len(parts) == 2:
+        org_raw, name_version = parts
+        org_safe = normalize_namespace(org_raw)
+    else:
+        org_safe, name_version = "splent_io", parts[0]
+    base_name, _, version = name_version.partition("@")
+    return org_safe, base_name, version or None
+
+
+def _frontend_root(workspace: str, feature: str) -> str | None:
+    """The working copy at the workspace root of an unpinned FEATURE when it
+    has frontend/ of its own, else None. A pinned one is never compiled."""
+    _, base_name, version = _split_ref(feature)
+    if version:
+        return None
+    root = os.path.join(workspace, base_name)
+    return root if frontend.declares(root) else None
+
+
+def _compile_frontend(root, feature, *, watch, production, release_build) -> bool:
+    """Build one feature's frontend/ in the SPLENT toolchain. False only
+    when the build failed or could not run.
+
+    Inside the product's web container there is no Docker daemon to run the
+    toolchain in. Its startup script compiles every feature with --watch,
+    and a feature with frontend/ is left to the CLI there, with a note.
+    """
+    namespace, base_name, _ = _split_ref(feature)
+    if _is_product_container() and not release_build:
         click.secho(
-            f"Compilation failed for {len(failed)} feature(s): {', '.join(failed)}",
-            fg="red",
-            err=True,
+            f"    {feature} builds in the SPLENT toolchain, not in this container: "
+            f"run splent feature:compile {base_name} --watch from the CLI.",
+            fg="bright_black",
         )
-        raise SystemExit(1)
+        return True
+
+    mode = "production" if production else "development"
+    click.echo(
+        click.style(f"🚀 Compiling {feature} in the SPLENT toolchain...", fg="cyan")
+    )
+    try:
+        image = frontend.ensure_toolchain()
+        frontend.install(root, image=image, force=release_build)
+        result = frontend.build(
+            root,
+            namespace,
+            base_name,
+            mode=mode,
+            watch=watch and not production,
+            image=image,
+        )
+    except click.ClickException as e:
+        click.secho(f"❌ Error compiling {feature}: {e.format_message()}", fg="red")
+        return False
+    if watch and not production:
+        if result.returncode != 0:
+            click.secho(
+                f"❌ The watch container of {feature} did not start:\n"
+                f"{(result.stderr or '').strip()}",
+                fg="red",
+            )
+            return False
+        name = frontend.watch_container(base_name)
+        click.echo(click.style(f"👀 Watching {feature} in {mode} mode...", fg="blue"))
+        click.echo(
+            click.style(
+                f"    log: docker logs -f {name}    stop: docker stop {name}",
+                fg="bright_black",
+            )
+        )
+        return True
+    if result.returncode != 0:
+        click.secho(f"❌ Error compiling {feature}: the build failed", fg="red")
+        return False
+    click.echo(
+        click.style(f"✅ Successfully compiled {feature} in {mode} mode!", fg="green")
+    )
+    return True
+
+
+def _verify_features(features, workspace: str) -> int:
+    """feature:compile --verify: 1 when the manifest of any feature with
+    frontend/ does not match its files, else 0. A pinned feature is checked
+    in the copy the product links, which is what its app serves."""
+    failed = 0
+    for feature in features:
+        namespace, base_name, version = _split_ref(feature)
+        if version:
+            product = context.require_app()
+            root = os.path.join(
+                workspace, product, "features", namespace, f"{base_name}@{version}"
+            )
+        else:
+            root = os.path.join(workspace, base_name)
+        if not frontend.declares(root):
+            click.echo(
+                click.style(
+                    f"    {feature} has no frontend/, nothing to verify.",
+                    fg="bright_black",
+                )
+            )
+            continue
+        problems = frontend.verify(root, namespace, base_name)
+        if problems:
+            failed += 1
+            click.secho(
+                f"❌ {feature}: the bundle does not match its manifest", fg="red"
+            )
+            for problem in problems:
+                click.secho(f"     {problem}", fg="red")
+        else:
+            click.secho(f"✅ {feature}: the bundle matches its manifest", fg="green")
+    return 1 if failed else 0
 
 
 def _feature_ref(name: str) -> str:

{splent_cli-1.44.0 → splent_cli-1.46.0}/src/splent_cli/commands/feature/feature_contract.py

@@ -21,6 +21,7 @@ from pathlib import Path
 
 from splent_cli.services import context
 from splent_cli.commands.feature.feature_release import (
+    _interactive,
     infer_contract,
     merge_preserved,
     requirement_problems,
@@ -341,8 +342,16 @@ def _print_diff(current: dict, inferred: dict) -> bool:
     is_flag=True,
     help="Write the inferred contract to pyproject.toml (default: dry-run only).",
 )
+@click.option(
+    "--inject-config/--no-inject-config",
+    "inject_config",
+    default=None,
+    help="With --write, run feature:inject-config when config.py is missing or "
+    "lacks a variable, without asking. Without a terminal and without either "
+    "flag it is not run.",
+)
 @context.requires_product
-def feature_contract(feature_ref, write):
+def feature_contract(feature_ref, write, inject_config):
     """
     Infer the feature contract from source code at any time during development.
 
@@ -362,6 +371,12 @@ def feature_contract(feature_ref, write):
     which a product's config.py may set. The keys of Flask, the framework,
     the extensions it sets up and other features are left out.
 
+    \b
+    When --write finds config.py missing, or missing a variable the feature
+    reads, it offers feature:inject-config. --inject-config runs it without
+    asking and --no-inject-config never does; without a terminal and
+    without either flag it is not run, and the command says how to run it.
+
     \b
     FEATURE_REF is a short name (notes), a package name
     (splent_feature_notes), either one under a namespace (splent-io/notes),
@@ -482,7 +497,7 @@ def feature_contract(feature_ref, write):
     click.secho("  ✅ Contract written to pyproject.toml.", fg="green")
 
     # Check if config.py needs updating
-    _check_config_py(cache_path, ns, name, inferred)
+    _check_config_py(cache_path, ns, name, inferred, inject_config)
 
     # And whether the settings it reads are declared where a product looks
     _check_declared_config(cache_path, inferred)
@@ -637,8 +652,29 @@ def _report_params(feature_path, name):
         )
 
 
-def _check_config_py(feature_path, ns, name, inferred):
-    """Warn if config.py is missing or stale relative to the inferred contract."""
+def _wants_inject_config(question: str, name: str, inject: bool | None) -> bool:
+    """Whether to run feature:inject-config: the flag when one was given,
+    else the answer to QUESTION. Without a terminal nobody can answer, and
+    click.confirm aborted the whole command after the contract was written,
+    so it is not asked and not run."""
+    if inject is not None:
+        return inject
+    if not _interactive():
+        click.secho(
+            f"     Not asked without a terminal. Run 'splent feature:inject-config "
+            f"{name}', or pass --inject-config.",
+            dim=True,
+        )
+        return False
+    return click.confirm(question, default=True)
+
+
+def _check_config_py(feature_path, ns, name, inferred, inject=None):
+    """Warn if config.py is missing or stale relative to the inferred contract.
+
+    ``inject`` is --inject-config (True), --no-inject-config (False) or
+    neither (None), see :func:`_wants_inject_config`.
+    """
     from splent_cli.commands.feature.feature_inject_config import (
         _is_regenerable,
         read_config_env_vars,
@@ -660,8 +696,8 @@ def _check_config_py(feature_path, ns, name, inferred):
             f"  ⚠  config.py not found — {len(env_vars)} env var(s) detected but not injected into app.config.",
             fg="yellow",
         )
-        if click.confirm(
-            "     Run feature:inject-config to generate it?", default=True
+        if _wants_inject_config(
+            "     Run feature:inject-config to generate it?", name, inject
         ):
             from splent_cli.commands.feature.feature_inject_config import (
                 feature_inject_config,
@@ -691,7 +727,9 @@ def _check_config_py(feature_path, ns, name, inferred):
                 dim=True,
             )
             return
-        if click.confirm("     Run feature:inject-config to update it?", default=True):
+        if _wants_inject_config(
+            "     Run feature:inject-config to update it?", name, inject
+        ):
             from splent_cli.commands.feature.feature_inject_config import (
                 feature_inject_config,
             )