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

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

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "splent_cli"
-version = "1.46.0"
+version = "1.48.0"
 description = "SPLENT-CLI is a CLI to be able to work on your development more easily."
 readme = "README.md"
 requires-python = ">=3.13"
@@ -78,8 +78,10 @@ where = ["src"]
 
 # The templates product:create, feature:create and the rest render. They are
 # data, not modules, so without this a wheel from PyPI shipped none of them.
+# The build context of the frontend toolchain image too, so a CLI installed
+# from PyPI can build the image a feature with frontend/ builds in.
 [tool.setuptools.package-data]
-splent_cli = ["templates/**/*"]
+splent_cli = ["templates/**/*", "toolchain/**/*"]
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]

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

@@ -1,8 +1,10 @@
+import dataclasses
 import logging
 import os
 import posixpath
 import shlex
 import subprocess
+from pathlib import Path
 
 import click
 
@@ -368,20 +370,43 @@ def _compile_frontend(root, feature, *, watch, production, release_build) -> boo
 
 
 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."""
+    """feature:compile --verify: 1 when the bundle of any feature with
+    frontend/ does not match its manifest, else 0.
+
+    A working copy is checked at the workspace root, a pinned feature in the
+    copy the product links, which is what its app serves, and where neither
+    is, as in the production image, in the package pip installed. When the
+    product has docker/frontend.lock.json (product:build writes it), every
+    feature it lists is checked too, and has to carry the manifest the lock
+    names, of the version it names: the bundle its release built.
+    """
+    from splent_cli.utils.frontend_check import read_lock
+
+    product = context.active_app(workspace)
+    lock = read_lock(os.path.join(workspace, product)) if product else None
+    locked = (lock or {}).get("features") or {}
+    refs = list(features)
+    named = {_split_ref(feature)[1] for feature in refs}
+    for name, entry in sorted(locked.items()):
+        if name not in named:
+            version = entry.get("version")
+            namespace = entry.get("namespace") or "splent_io"
+            refs.append(f"{namespace}/{name}" + (f"@v{version}" if version else ""))
+
     failed = 0
-    for feature in features:
+    for feature in refs:
         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}"
+        entry = locked.get(base_name)
+        copy = _copy_of(workspace, product, namespace, base_name, version)
+        if copy is None and entry is not None:
+            failed += 1
+            click.secho(
+                f"❌ {feature}: docker/frontend.lock.json lists it, and it is "
+                "neither here nor installed",
+                fg="red",
             )
-        else:
-            root = os.path.join(workspace, base_name)
-        if not frontend.declares(root):
+            continue
+        if entry is None and (copy is None or not copy.declares):
             click.echo(
                 click.style(
                     f"    {feature} has no frontend/, nothing to verify.",
@@ -389,7 +414,11 @@ def _verify_features(features, workspace: str) -> int:
                 )
             )
             continue
-        problems = frontend.verify(root, namespace, base_name)
+        problems = frontend.verify_assets(
+            copy.assets, lock=copy.lock, production=bool(version) or copy.installed
+        )
+        if entry is not None:
+            problems += _against_lock(copy, entry, base_name)
         if problems:
             failed += 1
             click.secho(
@@ -402,6 +431,101 @@ def _verify_features(features, workspace: str) -> int:
     return 1 if failed else 0
 
 
+@dataclasses.dataclass
+class _Copy:
+    """The copy of a feature --verify checks: its assets/, its frontend
+    lock (a package pip installed has none), whether pip installed it, and
+    whether it declares frontend/ (an installed one does when it carries a
+    manifest)."""
+
+    assets: Path
+    lock: Path | None
+    installed: bool
+    declares: bool
+
+
+def _copy_of(workspace, product, namespace, base_name, version) -> _Copy | None:
+    """The working copy, the product's link to a pinned release, or else
+    the package pip installed. None when there is none."""
+    if version:
+        root = (
+            os.path.join(
+                workspace, product, "features", namespace, f"{base_name}@{version}"
+            )
+            if product
+            else None
+        )
+    else:
+        root = os.path.join(workspace, base_name)
+    if root and os.path.isdir(root):
+        return _Copy(
+            frontend.assets_dir(root, namespace, base_name),
+            Path(root) / frontend.FRONTEND_DIR / frontend.LOCK,
+            False,
+            frontend.declares(root),
+        )
+    import importlib.util
+
+    try:
+        spec = importlib.util.find_spec(f"{namespace}.{base_name}")
+    except (ImportError, ValueError):
+        spec = None
+    if spec is None or not spec.submodule_search_locations:
+        return None
+    assets = Path(list(spec.submodule_search_locations)[0]) / "assets"
+    return _Copy(assets, None, True, (assets / "meta" / "manifest.json").is_file())
+
+
+def _against_lock(copy: _Copy, entry: dict, base_name: str) -> list[str]:
+    """What does not match between a feature's bundle and its entry in
+    docker/frontend.lock.json."""
+    problems = []
+    wanted = entry.get("manifest_sha256")
+    found = frontend.manifest_sha256(copy.assets)
+    if wanted and found and found != wanted:
+        problems.append(
+            "assets/meta/manifest.json is not the one docker/frontend.lock.json "
+            "names: run splent product:build"
+        )
+    if not copy.installed:
+        return problems
+    import importlib.metadata
+
+    distribution = entry.get("distribution") or base_name
+    try:
+        installed = importlib.metadata.version(distribution)
+    except importlib.metadata.PackageNotFoundError:
+        installed = None
+    if entry.get("version") and installed != entry["version"]:
+        problems.append(
+            f"pip installed {installed or 'no version'}, and "
+            f"docker/frontend.lock.json names {entry['version']}"
+        )
+    if found is None:
+        problems.append(
+            f"it was installed {_channel(distribution)}, without the bundle its "
+            "release built: release it again, so its wheel and its tag carry it"
+        )
+    return problems
+
+
+def _channel(distribution: str) -> str:
+    """How pip installed DISTRIBUTION: from its git tag (git+) or a wheel."""
+    import importlib.metadata
+    import json
+
+    try:
+        direct = importlib.metadata.distribution(distribution).read_text(
+            "direct_url.json"
+        )
+        url = json.loads(direct or "{}")
+    except (importlib.metadata.PackageNotFoundError, ValueError):
+        url = {}
+    if "vcs_info" in url:
+        return f"from its git tag (git+{url.get('url', '')})"
+    return "from a wheel"
+
+
 def _feature_ref(name: str) -> str:
     """*name* as typed, with the ``splent_feature_`` prefix on the feature's
     own name: ``auth`` and ``splent_io/auth`` are ``splent_feature_auth``

{splent_cli-1.46.0 → splent_cli-1.48.0}/src/splent_cli/commands/feature/feature_release.py

@@ -237,6 +237,68 @@ def _extract_templates(src_dir: Path) -> list[str]:
 
 
 _SLOT_CALL = re.compile(r"""(?:get|render)_template_hooks\s*\(\s*['"]([^'"]+)['"]""")
+_SLOT_FUNCTIONS = ("get_template_hooks", "render_template_hooks")
+_MACRO = re.compile(
+    r"\{%-?\s*macro\s+(\w+)\s*\(\s*(\w+)(.*?)\{%-?\s*endmacro", re.DOTALL
+)
+
+
+def _python_slot_helpers(source: str) -> set[str]:
+    """The functions of SOURCE that open the slot their first argument
+    names: they hand it to get_template_hooks or render_template_hooks."""
+    try:
+        tree = ast.parse(source)
+    except SyntaxError:
+        return set()
+    helpers = set()
+    for node in ast.walk(tree):
+        if not isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            continue
+        params = [arg.arg for arg in node.args.posonlyargs + node.args.args]
+        if params[:1] in (["self"], ["cls"]):
+            params = params[1:]
+        if not params:
+            continue
+        for call in ast.walk(node):
+            if not isinstance(call, ast.Call) or not call.args:
+                continue
+            called = call.func
+            if isinstance(called, ast.Attribute):
+                name = called.attr
+            elif isinstance(called, ast.Name):
+                name = called.id
+            else:
+                name = None
+            first = call.args[0]
+            if (
+                name in _SLOT_FUNCTIONS
+                and isinstance(first, ast.Name)
+                and first.id == params[0]
+            ):
+                helpers.add(node.name)
+                break
+    return helpers
+
+
+def _template_slot_helpers(source: str) -> set[str]:
+    """The macros of SOURCE that open the slot their first argument names."""
+    helpers = set()
+    for name, param, body in _MACRO.findall(source):
+        opens = re.compile(
+            r"(?:get|render)_template_hooks\s*\(\s*" + re.escape(param) + r"\s*[,)]"
+        )
+        if opens.search(body):
+            helpers.add(name)
+    return helpers
+
+
+def _helper_calls(helpers: set[str]) -> re.Pattern | None:
+    """A call of one of HELPERS with a slot name as its first argument, as
+    a template writes it: ``hub.slot_of("x.y", …)`` or ``slot_of('x.y')``."""
+    if not helpers:
+        return None
+    names = "|".join(re.escape(name) for name in sorted(helpers))
+    return re.compile(r"""\b(?:""" + names + r""")\s*\(\s*['"]([^'"]+)['"]""")
 
 
 def _extract_template_hook_slots(src_dir: Path) -> list[str]:
@@ -250,19 +312,38 @@ def _extract_template_hook_slots(src_dir: Path) -> list[str]:
     that slot is as much the feature's: a scan of the templates alone left
     it out of ``extensible.hooks``. Tests are not the feature's code, and a
     layout.* slot the code reads is the product's.
+
+    A helper may also take the slot's name from its caller: a function of
+    the feature's Python, or a macro of its templates, that hands its first
+    argument to one of the two. Then the slot is the literal a template
+    (or the code) passes it, ``shell.slot_of("layout.sidebar", …)``.
     """
     if not src_dir.exists():
         return []
     slots: set[str] = set()
     templates_dir = src_dir / "templates"
+    templates = {}
     if templates_dir.exists():
         for html_file in templates_dir.rglob("*.html"):
-            slots.update(_SLOT_CALL.findall(html_file.read_text()))
+            templates[html_file] = html_file.read_text()
+    sources = {}
     for py_file in _feature_sources(src_dir):
         try:
-            found = _SLOT_CALL.findall(py_file.read_text())
+            sources[py_file] = py_file.read_text()
         except (OSError, UnicodeDecodeError):
             continue
+    helpers = set()
+    for text in sources.values():
+        helpers |= _python_slot_helpers(text)
+    for text in templates.values():
+        helpers |= _template_slot_helpers(text)
+    calls = _helper_calls(helpers)
+    for text in templates.values():
+        slots.update(_SLOT_CALL.findall(text))
+        if calls:
+            slots.update(calls.findall(text))
+    for text in sources.values():
+        found = _SLOT_CALL.findall(text) + (calls.findall(text) if calls else [])
         slots.update(s for s in found if not s.startswith(_PRODUCT_SLOT_PREFIX))
     return sorted(slots)
 

{splent_cli-1.46.0 → splent_cli-1.48.0}/src/splent_cli/commands/product/product_build.py

@@ -62,6 +62,10 @@ LEGACY_REQUIREMENTS_FILE = "requirements.prod.txt"
 # Dockerfile applies it as a constraint on every pip install, so two builds of
 # one commit install the same set. Versioned in docker/.
 LOCK_FILE = "requirements.lock"
+# What the features' bundles are and ship, which the image verifies the
+# installed ones against (splent_cli.utils.frontend_check). Versioned in
+# docker/ too.
+FRONTEND_LOCK_FILE = "frontend.lock.json"
 LOCK_HEADER = (
     "# Every third-party package the production image installs, at the version\n"
     "# the last build resolved. Written by splent product:build and\n"
@@ -1202,6 +1206,30 @@ def _contracts_snapshot(workspace: str, declared_features: Sequence[str]) -> dic
     return {"format": CONTRACTS_FORMAT, "features": features}
 
 
+def write_frontend_lock(
+    workspace: str, product_path: str, data: dict, declared_features: Sequence[str]
+) -> str:
+    """Write docker/frontend.lock.json for the features the image installs.
+
+    For each one with frontend/, the release, the sha256 of the manifest its
+    bundle carries and what the bundle ships, with the provider that
+    satisfies each of its peers; the shell; and the features still built in
+    legacy mode (splent_cli.utils.frontend_check.lock). The production
+    image checks every bundle pip installed against it, and the product's
+    CI audits what they ship from it. Returns its path.
+    """
+    from splent_cli.utils import frontend_check
+
+    check = frontend_check.check_product(workspace, product_path, declared_features)
+    path = os.path.join(product_path, "docker", FRONTEND_LOCK_FILE)
+    atomic_write(
+        path,
+        frontend_check.lock_text(frontend_check.lock(check, data)),
+        dir_owner=True,
+    )
+    return path
+
+
 def _not_shipped(directory, names):
     """Bytecode a local run of a feature left behind, never part of the bundle."""
     return {n for n in names if n == "__pycache__" or n.endswith(".pyc")}
@@ -1481,7 +1509,8 @@ def write_deploy_artifacts(
     * ``[tool.splent.runtime]`` in pyproject.toml, the framework and CLI the
       image installs from PyPI;
     * ``splent.contracts.json`` and ``docker/spl/``, the refinement metadata
-      and the UVL model the image reads.
+      and the UVL model the image reads;
+    * ``docker/frontend.lock.json``, the bundles the image verifies.
 
     All of them are versioned with the product. product:build and
     product:release both go through here, so a release commits exactly what
@@ -1791,6 +1820,12 @@ def write_deploy_artifacts(
     written.append(CONTRACTS_SNAPSHOT)
     click.echo(f"✅ Created: {contracts_path}")
 
+    frontend_lock = write_frontend_lock(
+        workspace, product_path, data, declared_features
+    )
+    written.append(f"docker/{FRONTEND_LOCK_FILE}")
+    click.echo(f"✅ Created: {frontend_lock}")
+
     staged_model = stage_spl_model(workspace, product, docker_path)
     if staged_model:
         written.append(f"docker/{SPL_STAGING_DIR}")