splent-cli 1.50.1__tar.gz → 1.52.0__tar.gz

{splent_cli-1.50.1/src/splent_cli.egg-info → splent_cli-1.52.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: splent_cli
-Version: 1.50.1
+Version: 1.52.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.50.1 → splent_cli-1.52.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "splent_cli"
-version = "1.50.1"
+version = "1.52.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.50.1 → splent_cli-1.52.0}/src/splent_cli/commands/product/product_release.py

@@ -6,6 +6,7 @@ import contextlib
 import json
 import os
 import subprocess
+import sys
 import tempfile
 
 import click
@@ -28,6 +29,8 @@ from splent_cli.services import (
     image_registry,
     release,
     release_gate,
+    release_workspace,
+    source_mirror,
 )
 from splent_cli.utils.proc import run, require_docker
 
@@ -39,19 +42,9 @@ def _guard_all_features_pinned(product_path: str):
     features_prod declare, so an editable entry in any of them makes the
     release irreproducible, not only one in the base list.
     """
-    from splent_cli.utils.feature_utils import (
-        FEATURE_LIST_KEYS,
-        load_product_pyproject,
-        read_feature_list,
-    )
+    from splent_cli.utils.feature_utils import load_product_pyproject
 
-    data = load_product_pyproject(product_path)
-    editable = [
-        (key, entry)
-        for key in FEATURE_LIST_KEYS
-        for entry in read_feature_list(data, key)
-        if "@" not in entry
-    ]
+    editable = release_workspace.editable_features(load_product_pyproject(product_path))
     if not editable:
         return
 
@@ -385,6 +378,12 @@ def _left_out_flags(channels) -> list[str]:
     is_flag=True,
     help="Do not build or push the Docker image for this version.",
 )
+@click.option(
+    "--no-mirror",
+    is_flag=True,
+    help="Do not publish to [tool.splent.release.source_mirror] now, for when it "
+    "is down. splent release:resume does it later.",
+)
 @click.option(
     "--allow-unfinished",
     is_flag=True,
@@ -403,6 +402,7 @@ def product_release(
     no_forge,
     no_github,
     no_docker,
+    no_mirror,
     allow_unfinished,
     wait,
 ):
@@ -419,8 +419,16 @@ def product_release(
         click.secho(f"  error: pyproject.toml not found in {product}", fg="red")
         raise SystemExit(1)
 
+    if release_workspace.in_development_mode(product_path):
+        raise SystemExit(
+            release_workspace.run_from_head(
+                product, product_path, str(context.workspace()), sys.argv[1:]
+            )
+        )
+
     _guard_all_features_pinned(product_path)
     _guard_deployable(str(context.workspace()), product, product_path)
+    mirror = None if no_mirror else _declared_source_mirror(product_path)
 
     # Determine org/repo for the semver wizard
     repo = release.get_repo_from_path(product_path)
@@ -502,7 +510,16 @@ def product_release(
         ),
         post_pypi_hook=_docker_hook,
         wait=wait,
+        source_mirror=mirror,
     )
 
 
+def _declared_source_mirror(product_path: str):
+    try:
+        return source_mirror.declared(os.path.join(product_path, "pyproject.toml"))
+    except source_mirror.MirrorDeclarationError as e:
+        click.secho(f"  error: {e}", fg="red")
+        raise SystemExit(1)
+
+
 cli_command = product_release

{splent_cli-1.50.1 → splent_cli-1.52.0}/src/splent_cli/commands/release/release_resume.py

@@ -33,11 +33,18 @@ import contextlib
 import os
 import shutil
 import subprocess
+import sys
 import tempfile
 
 import click
 
-from splent_cli.services import context, release, release_gate
+from splent_cli.services import (
+    context,
+    release,
+    release_gate,
+    release_workspace,
+    source_mirror,
+)
 from splent_cli.utils import forge
 from splent_cli.utils.git_url import _non_interactive_env
 
@@ -322,6 +329,13 @@ def release_resume(target, assume_yes, no_pypi, no_forge, no_github, no_docker,
     no_forge = release.no_forge_requested(no_forge, no_github)
     workspace = str(context.workspace())
     path, label, kind = resolve_target(target, workspace)
+    if kind == "product" and release_workspace.in_development_mode(path):
+        raise SystemExit(
+            release_workspace.run_from_head(
+                os.path.basename(path), path, workspace, sys.argv[1:]
+            )
+        )
+
     # What the hints this run prints tell the operator to run next. A withheld
     # image stays withheld.
     hint_target = f"{target} --no-docker" if no_docker else target
@@ -539,6 +553,27 @@ def release_resume(target, assume_yes, no_pypi, no_forge, no_github, no_docker,
     if make_snapshot:
         steps.append(f"create the local snapshot for {tag}")
 
+    # The product's official repository, once the forge has what it copies.
+    mirror = None
+    if kind == "product" and release_gate.FORGE in channels:
+        try:
+            mirror = source_mirror.declared(pyproject)
+            if mirror:
+                mirror_steps = source_mirror.missing(mirror, path, tag)
+                steps.extend(mirror_steps)
+                mirror = mirror if mirror_steps else None
+        except source_mirror.MirrorDeclarationError as e:
+            click.secho(f"  error: {e}", fg="red")
+            raise SystemExit(1)
+        except source_mirror.MirrorUnreachable as e:
+            stuck.append(
+                release_gate.ChannelStatus(
+                    source_mirror.CHANNEL,
+                    summary=f"could not ask {mirror.web_url} what it has ({e})",
+                )
+            )
+            mirror = None
+
     click.echo()
     if not steps:
         if stuck:
@@ -675,6 +710,11 @@ def release_resume(target, assume_yes, no_pypi, no_forge, no_github, no_docker,
         if failure:
             failures.append(f"the release for {tag} on the forge ({failure})")
 
+    if mirror:
+        failure = source_mirror.publish(mirror, path, tag)
+        if failure:
+            failures.append(f"{tag} on {mirror.web_url} ({failure})")
+
     if push_image:
         from splent_cli.commands.product.product_release import release_docker_image
 

{splent_cli-1.50.1 → splent_cli-1.52.0}/src/splent_cli/services/frontend.py

@@ -740,6 +740,10 @@ def verify_assets(assets, *, lock=None, production: bool = False) -> list[str]:
     if dist.is_dir():
         for path in sorted(dist.rglob("*")):
             name = path.relative_to(dist).as_posix()
+            # pip compiles the .py a bundle ships to the browser (a pyodide
+            # wrapper) where it installs it: that bytecode is no file of it.
+            if "__pycache__" in path.parts:
+                continue
             if path.is_file() and name not in listed:
                 problems.append(f"assets/dist/{name} is not in the manifest")
     if lock is not None and Path(lock).is_file():

{splent_cli-1.50.1 → splent_cli-1.52.0}/src/splent_cli/services/registry.py

@@ -402,27 +402,33 @@ def github_create_release(
     draft: bool = False,
     prerelease: bool = False,
     timeout: int = 30,
+    api_base: str | None = None,
+    generate_notes: bool = False,
 ) -> ReleaseResult:
-    """Create a release for *tag* on the configured forge.
+    """Create a release for *tag* on the configured forge, or at *api_base*.
 
     Returns the outcome instead of raising for HTTP failures, so the caller can
     tell "already there" (idempotent rerun) from "refused" (a divergence, since
     the tag exists by the time this runs). Raises :class:`RegistryError` only
     when the forge cannot be reached at all.
+
+    ``generate_notes`` asks GitHub to append what changed since the last release
+    to *body*. Only GitHub knows it.
     """
-    payload = json.dumps(
-        {
-            "tag_name": tag,
-            "name": name,
-            "body": body,
-            "draft": draft,
-            "prerelease": prerelease,
-        }
-    ).encode()
+    fields = {
+        "tag_name": tag,
+        "name": name,
+        "body": body,
+        "draft": draft,
+        "prerelease": prerelease,
+    }
+    if generate_notes:
+        fields["generate_release_notes"] = True
+    payload = json.dumps(fields).encode()
     headers = _github_headers(token)
     headers["Content-Type"] = "application/json"
     req = _forge_request(
-        f"{forge.api_base()}/repos/{org}/{repo}/releases",
+        f"{api_base or forge.api_base()}/repos/{org}/{repo}/releases",
         data=payload,
         headers=headers,
         method="POST",

{splent_cli-1.50.1 → splent_cli-1.52.0}/src/splent_cli/services/release.py

@@ -16,6 +16,7 @@ import tomllib
 import click
 
 from splent_cli.services import release_gate
+from splent_cli.services import source_mirror as source_mirror_service
 from splent_cli.utils import forge
 from splent_cli.utils.git_url import _non_interactive_env
 from splent_cli.utils.io_utils import atomic_write
@@ -1619,6 +1620,7 @@ def run_release_pipeline(
     post_pypi_hook=None,
     wait: bool = False,
     neutral: bool = False,
+    source_mirror=None,
 ):
     """Run the standard release pipeline.
 
@@ -1634,7 +1636,8 @@ def run_release_pipeline(
      7. Commit                                         (local, revertible)
      8. Build and upload to PyPI
      9. Push the branch, the tag, and create the release on the git host
-    10. (optional) post_pypi_hook, e.g. the snapshot or the Docker image
+    10. (optional) the same on source_mirror, the product's official repository
+    11. (optional) post_pypi_hook, e.g. the snapshot or the Docker image
 
     The order of 8 and 9 is the point. A PyPI version can never be replaced or
     removed; a tag that was never pushed costs nothing. Uploading first means a
@@ -1714,6 +1717,10 @@ def run_release_pipeline(
             deep=deep,
             allow_unfinished=allow_unfinished,
         )
+        if source_mirror and to_forge:
+            report.statuses.append(
+                source_mirror_service.check(source_mirror, path, tag)
+            )
         release_gate.render(report, header=header)
         if not report.ok:
             release_gate.refuse(report, resume_target=target)
@@ -1852,6 +1859,14 @@ def run_release_pipeline(
             )
             if failure:
                 failures.append(f"the release for {tag} on the git host ({failure})")
+            # Before the image: the version the image reaches production with
+            # must already have its page where the app links to it.
+            if source_mirror:
+                failure = source_mirror_service.publish(source_mirror, path, tag)
+                if failure:
+                    failures.append(f"{tag} on {source_mirror.web_url} ({failure})")
+                else:
+                    accepted.append(source_mirror.web_url)
         else:
             create_and_push_tag(path, tag, push=False)
             click.secho(

{splent_cli-1.50.1 → splent_cli-1.52.0}/src/splent_cli/services/release_gate.py

@@ -195,7 +195,7 @@ def canonical_channel(name) -> str:
     return CHANNEL_ALIASES.get(key, key)
 
 
-_RELEASE_KEYS = {"channels", "registries", "mirrors"}
+_RELEASE_KEYS = {"channels", "registries", "mirrors", "source_mirror"}
 
 
 def declared_channels(pyproject_path: str) -> tuple[str, ...]:
@@ -234,7 +234,7 @@ def declared_channels(pyproject_path: str) -> tuple[str, ...]:
         raise ChannelDeclarationError(
             "[tool.splent.release] has unknown key(s) "
             + ", ".join(unknown)
-            + ". The keys are 'channels', 'registries' and 'mirrors', so this was "
+            + ". The keys are 'channels', 'registries', 'mirrors' and 'source_mirror', so this was "
             "ignored silently before."
         )
 

splent_cli-1.52.0/src/splent_cli/services/release_workspace.py

@@ -0,0 +1,180 @@
+"""Releasing what HEAD holds while the checkout is in development mode.
+
+A product under development lists its features without a version in
+pyproject.toml, uncommitted, so the app mounts their working copies. HEAD keeps
+them pinned. Such a checkout cannot release as it is, and it should not have to
+change either: a release is what is committed.
+
+So product:release and release:resume run from a temporary workspace of their
+own, a worktree of HEAD next to the cache and the product line's model, and the
+checkout moves forward afterwards with its pyproject.toml as it was, bar what
+the release changed in it.
+"""
+
+from __future__ import annotations
+
+import glob
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+import tomllib
+
+import click
+
+from splent_cli.utils.feature_utils import (
+    FEATURE_LIST_KEYS,
+    load_product_pyproject,
+    read_feature_list,
+)
+
+PYPROJECT = "pyproject.toml"
+
+
+def editable_features(data: dict) -> list[tuple[str, str]]:
+    """``(list, entry)`` of every feature of a pyproject with no version pinned.
+
+    Every list counts. A release runs whatever features, features_dev and
+    features_prod declare.
+    """
+    return [
+        (key, entry)
+        for key in FEATURE_LIST_KEYS
+        for entry in read_feature_list(data, key)
+        if "@" not in entry
+    ]
+
+
+def _git(path: str, *args: str) -> subprocess.CompletedProcess:
+    return subprocess.run(["git", *args], cwd=path, capture_output=True, text=True)
+
+
+def in_development_mode(product_path: str) -> bool:
+    """Whether the checkout has editable features and HEAD has none."""
+    if not editable_features(load_product_pyproject(product_path)):
+        return False
+    head = _git(product_path, "show", f"HEAD:{PYPROJECT}")
+    if head.returncode != 0:
+        return False
+    try:
+        return not editable_features(tomllib.loads(head.stdout))
+    except tomllib.TOMLDecodeError:
+        return False
+
+
+def _splent(args: list[str], env: dict) -> int:
+    """Run the CLI in the temporary workspace, in this terminal."""
+    return subprocess.run(
+        [sys.executable, "-m", "splent_cli", *args], env=env
+    ).returncode
+
+
+def _merged_pyproject(path: str, ours: str, base: str, theirs: str) -> str | None:
+    """Three-way merge of the checkout's pyproject.toml, None on a conflict."""
+    with tempfile.TemporaryDirectory(prefix="splent_pyproject_") as tmp:
+        names = []
+        for name, content in (("ours", ours), ("base", base), ("theirs", theirs)):
+            names.append(os.path.join(tmp, name))
+            with open(names[-1], "w", encoding="utf-8") as f:
+                f.write(content)
+        merged = _git(path, "merge-file", "-p", *names)
+    return merged.stdout if merged.returncode == 0 else None
+
+
+def _bring_checkout_forward(product_path: str, start: str, end: str) -> None:
+    """Move the checkout to *end*, its development pyproject.toml kept.
+
+    Says so when it cannot, and leaves the checkout exactly as it found it.
+    """
+    hint = f"Your checkout stays where it was. When it can, run git merge --ff-only {end[:12]}."
+    if _git(product_path, "rev-parse", "HEAD").stdout.strip() != start:
+        click.secho(f"  checkout HEAD moved during the release. {hint}", fg="yellow")
+        return
+    pyproject = os.path.join(product_path, PYPROJECT)
+    with open(pyproject, encoding="utf-8") as f:
+        ours = f.read()
+    merged = _merged_pyproject(
+        product_path,
+        ours,
+        _git(product_path, "show", f"{start}:{PYPROJECT}").stdout,
+        _git(product_path, "show", f"{end}:{PYPROJECT}").stdout,
+    )
+    if merged is None:
+        click.secho(
+            f"  checkout your {PYPROJECT} and the release's do not merge. {hint}",
+            fg="yellow",
+        )
+        return
+
+    result = merged
+    moved = False
+    try:
+        _git(product_path, "checkout", "--", PYPROJECT)
+        forward = _git(product_path, "merge", "--ff-only", "--quiet", end)
+        moved = forward.returncode == 0
+        if not moved:
+            result = ours
+            click.secho(
+                f"  checkout {forward.stderr.strip()}\n  checkout {hint}", fg="yellow"
+            )
+    except OSError as e:
+        result = ours
+        click.secho(f"  checkout {e}. {hint}", fg="yellow")
+    finally:
+        with open(pyproject, "w", encoding="utf-8") as f:
+            f.write(result)
+    if moved:
+        click.echo(f"  checkout now at {end[:12]}, your {PYPROJECT} is kept")
+
+
+def run_from_head(
+    product: str, product_path: str, workspace: str, argv: list[str]
+) -> int:
+    """Run this command in a temporary workspace holding HEAD. Its exit code.
+
+    The checkout ends where a release run in it would have, commit included
+    when the command stopped halfway, so release:resume can go on from it.
+    """
+    start = _git(product_path, "rev-parse", "HEAD").stdout.strip()
+    click.secho(
+        f"  checkout {product} has editable features, so this works from what HEAD "
+        f"holds ({start[:12]}).",
+        fg="cyan",
+    )
+    status = _git(product_path, "status", "--porcelain").stdout.splitlines()
+    left_out = [line[3:] for line in status if line[3:] != PYPROJECT]
+    if left_out:
+        click.secho(
+            "  checkout uncommitted, so left out: "
+            + ", ".join(left_out[:5])
+            + (" ..." if len(left_out) > 5 else ""),
+            fg="yellow",
+        )
+
+    temporary = tempfile.mkdtemp(prefix="splent_release_")
+    worktree = os.path.join(temporary, product)
+    try:
+        cache = os.path.join(workspace, ".splent_cache")
+        for path in [cache, *glob.glob(os.path.join(workspace, "splent_spl_*"))]:
+            if os.path.exists(path):
+                os.symlink(path, os.path.join(temporary, os.path.basename(path)))
+        added = _git(product_path, "worktree", "add", "--detach", worktree, start)
+        if added.returncode != 0:
+            click.secho(f"  error: {added.stderr.strip()}", fg="red")
+            return 1
+
+        env = {**os.environ, "WORKING_DIR": temporary, "SPLENT_APP": product}
+        code = _splent(["product:resolve", "--prod", "--strict"], env)
+        if code != 0:
+            return code
+        code = _splent(argv, env)
+
+        end = _git(worktree, "rev-parse", "HEAD").stdout.strip()
+        if end and end != start:
+            _bring_checkout_forward(product_path, start, end)
+        return code
+    finally:
+        _git(product_path, "worktree", "remove", "--force", worktree)
+        _git(product_path, "worktree", "prune")
+        shutil.rmtree(temporary, ignore_errors=True)