splent-cli 1.50.0__tar.gz → 1.51.0__tar.gz

{splent_cli-1.50.0/src/splent_cli.egg-info → splent_cli-1.51.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: splent_cli
-Version: 1.50.0
+Version: 1.51.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.0 → splent_cli-1.51.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "splent_cli"
-version = "1.50.0"
+version = "1.51.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.0 → splent_cli-1.51.0}/src/splent_cli/commands/check/check_deps.py

@@ -83,6 +83,48 @@ def _parse_uvl_deps(uvl_path: str) -> tuple[dict[str, str], dict[str, set[str]]]
 # ---------------------------------------------------------------------------
 
 
+def _bare_imports(source: str) -> set[str]:
+    """The features an import statement of SOURCE names outside a guard.
+
+    An import under a try whose handler tolerates ImportError, or under an
+    if that asks whether the product has the feature, is how a feature
+    reaches an optional one (feature:release reads it so for the contract),
+    and the product does without it. A source that does not parse is read
+    as text, every import counting.
+    """
+    import ast
+
+    from splent_cli.commands.feature.feature_release import (
+        _IMPORT_TOLERANT_HANDLERS,
+        _guarded_ranges,
+        _imported_names,
+        _in_ranges,
+        _module_string_constants,
+        _presence_guards,
+    )
+
+    try:
+        tree = ast.parse(source)
+    except (SyntaxError, ValueError):
+        return set(
+            re.findall(r"(?:from|import)\s+splent_io\.(splent_feature_\w+)", source)
+        )
+    guarded = _guarded_ranges(tree, _IMPORT_TOLERANT_HANDLERS)
+    present = _presence_guards(tree, _module_string_constants(tree))
+    found = set()
+    for node in ast.walk(tree):
+        if not isinstance(node, (ast.Import, ast.ImportFrom)):
+            continue
+        for item in _imported_names(node):
+            for short in re.findall(r"^splent_io\.splent_feature_(\w+?)(?:\.|$)", item):
+                if _in_ranges(node.lineno, guarded) or _in_ranges(
+                    node.lineno, present.get(short, ())
+                ):
+                    continue
+                found.add(f"splent_feature_{short}")
+    return found
+
+
 def _scan_feature_imports(
     feature_path: str, feature_name: str, all_packages: set[str]
 ) -> tuple[set[str], set[str]]:
@@ -130,9 +172,7 @@ def _scan_feature_imports(
                 except (OSError, PermissionError):
                     continue
 
-                for match in re.findall(
-                    r"(?:from|import)\s+splent_io\.(splent_feature_\w+)", content
-                ):
+                for match in _bare_imports(content):
                     if match != feature_name and match in all_packages:
                         python_imports.add(match)
 

{splent_cli-1.50.0 → splent_cli-1.51.0}/src/splent_cli/commands/product/product_release.py

@@ -28,6 +28,7 @@ from splent_cli.services import (
     image_registry,
     release,
     release_gate,
+    source_mirror,
 )
 from splent_cli.utils.proc import run, require_docker
 
@@ -385,6 +386,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 +410,7 @@ def product_release(
     no_forge,
     no_github,
     no_docker,
+    no_mirror,
     allow_unfinished,
     wait,
 ):
@@ -421,6 +429,7 @@ def product_release(
 
     _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 +511,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.0 → splent_cli-1.51.0}/src/splent_cli/commands/release/release_resume.py

@@ -37,7 +37,7 @@ import tempfile
 
 import click
 
-from splent_cli.services import context, release, release_gate
+from splent_cli.services import context, release, release_gate, source_mirror
 from splent_cli.utils import forge
 from splent_cli.utils.git_url import _non_interactive_env
 
@@ -539,6 +539,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 +696,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.0 → splent_cli-1.51.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.0 → splent_cli-1.51.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.0 → splent_cli-1.51.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.0 → splent_cli-1.51.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.51.0/src/splent_cli/services/source_mirror.py

@@ -0,0 +1,356 @@
+"""A product's official repository, when it is not the forge it releases to.
+
+A product lives on the forge, with its CI, its tags and its image registry, and
+its public home can be somewhere else. A release has to reach that home too: the
+page of a version is often linked from the app itself, so an image that reaches
+production before its release exists there links to a 404.
+
+    [tool.splent.release.source_mirror]
+    url = "https://github.com/org/repo"
+    branches = ["main", "develop"]
+
+A release moves every branch named to the commit of its tag, pushes the tag and
+creates the release there, before the image goes out. Branches only ever move
+forward: a mirror with commits this repository lacks refuses the release at the
+gate, before anything changes.
+
+The push goes over SSH, as the forge's does. The API call takes a token, from
+SPLENT_SOURCE_MIRROR_TOKEN, GH_TOKEN, the GitHub CLI's login or GITHUB_TOKEN.
+"""
+
+from __future__ import annotations
+
+import dataclasses
+import os
+import shutil
+import subprocess
+import tomllib
+from urllib.parse import urlparse
+
+import click
+
+from splent_cli.services import registry, release_gate
+from splent_cli.utils.git_url import _non_interactive_env
+
+CHANNEL = "mirror"
+GITHUB_HOST = "github.com"
+GIT_NETWORK_TIMEOUT = 600
+
+
+class MirrorDeclarationError(ValueError):
+    """[tool.splent.release.source_mirror] does not say what a release needs."""
+
+
+class MirrorUnreachable(Exception):
+    """The mirror could not be asked what it has."""
+
+
+@dataclasses.dataclass(frozen=True)
+class SourceMirror:
+    host: str
+    org: str
+    repo: str
+    branches: tuple[str, ...]
+    push_url: str
+
+    @property
+    def web_url(self) -> str:
+        return f"https://{self.host}/{self.org}/{self.repo}"
+
+    @property
+    def is_github(self) -> bool:
+        return self.host == GITHUB_HOST
+
+    @property
+    def api_base(self) -> str:
+        if self.is_github:
+            return "https://api.github.com"
+        return f"https://{self.host}/api/v1"
+
+
+def declared(pyproject_path: str) -> SourceMirror | None:
+    """The mirror the product's pyproject.toml declares, or None."""
+    try:
+        with open(pyproject_path, "rb") as f:
+            data = tomllib.load(f)
+    except (OSError, tomllib.TOMLDecodeError):
+        return None
+    section = (
+        data.get("tool", {}).get("splent", {}).get("release", {}).get("source_mirror")
+    )
+    if section is None:
+        return None
+    if not isinstance(section, dict):
+        raise MirrorDeclarationError(
+            "[tool.splent.release.source_mirror] must be a table with a url."
+        )
+
+    url = section.get("url")
+    parsed = urlparse(url) if isinstance(url, str) else None
+    parts = [p for p in parsed.path.split("/") if p] if parsed else []
+    if not parsed or parsed.scheme != "https" or not parsed.hostname or len(parts) != 2:
+        raise MirrorDeclarationError(
+            "[tool.splent.release.source_mirror] url must be the repository's web "
+            'address, for example url = "https://github.com/org/repo".'
+        )
+    org, repo = parts[0], parts[1].removesuffix(".git")
+
+    branches = section.get("branches", ["main"])
+    if (
+        not isinstance(branches, list)
+        or not branches
+        or not all(isinstance(b, str) and b.strip() for b in branches)
+    ):
+        raise MirrorDeclarationError(
+            "[tool.splent.release.source_mirror] branches must be a list of branch "
+            'names, for example branches = ["main"].'
+        )
+    return SourceMirror(
+        host=parsed.hostname,
+        org=org,
+        repo=repo,
+        branches=tuple(dict.fromkeys(b.strip() for b in branches)),
+        push_url=f"git@{parsed.hostname}:{org}/{repo}.git",
+    )
+
+
+def token(mirror: SourceMirror) -> str | None:
+    """The token for the mirror's API. Never printed."""
+    explicit = os.getenv("SPLENT_SOURCE_MIRROR_TOKEN") or os.getenv("GH_TOKEN")
+    if explicit:
+        return explicit
+    gh = shutil.which("gh")
+    if gh:
+        try:
+            result = subprocess.run(
+                [gh, "auth", "token", "--hostname", mirror.host],
+                capture_output=True,
+                text=True,
+                timeout=15,
+            )
+        except (OSError, subprocess.TimeoutExpired):
+            result = None
+        if result is not None and result.returncode == 0 and result.stdout.strip():
+            return result.stdout.strip()
+    return os.getenv("GITHUB_TOKEN") if mirror.is_github else None
+
+
+def _git(path: str, *args: str) -> subprocess.CompletedProcess:
+    return subprocess.run(
+        ["git", *args],
+        cwd=path,
+        capture_output=True,
+        text=True,
+        env=_non_interactive_env(),
+        timeout=GIT_NETWORK_TIMEOUT,
+    )
+
+
+def _remote_refs(mirror: SourceMirror, path: str) -> dict[str, str]:
+    """``{ref: sha}`` of the mirror's branches and tags."""
+    try:
+        result = _git(path, "ls-remote", "--heads", "--tags", mirror.push_url)
+    except (OSError, subprocess.TimeoutExpired) as e:
+        raise MirrorUnreachable(f"git ls-remote did not finish ({e})") from e
+    if result.returncode != 0:
+        raise MirrorUnreachable(result.stderr.strip() or "git ls-remote failed")
+    refs = {}
+    for line in result.stdout.splitlines():
+        sha, _, ref = line.partition("\t")
+        if ref:
+            refs[ref] = sha
+    return refs
+
+
+def _have_commit(mirror: SourceMirror, path: str, sha: str, branch: str) -> bool:
+    """Whether *sha*, the tip of the mirror's *branch*, is here, fetching it if not."""
+    if _git(path, "cat-file", "-e", f"{sha}^{{commit}}").returncode == 0:
+        return True
+    _git(path, "fetch", "--no-tags", mirror.push_url, f"refs/heads/{branch}")
+    return _git(path, "cat-file", "-e", f"{sha}^{{commit}}").returncode == 0
+
+
+def _is_ancestor(path: str, ancestor: str, descendant: str) -> bool:
+    result = _git(path, "merge-base", "--is-ancestor", ancestor, descendant)
+    return result.returncode == 0
+
+
+def check(mirror: SourceMirror, path: str, tag: str) -> release_gate.ChannelStatus:
+    """Will the mirror take this release? Doubt counts as blocked, as in the gate."""
+    st = release_gate.ChannelStatus(CHANNEL)
+
+    def blocked(summary: str, *hints: str) -> release_gate.ChannelStatus:
+        st.summary = f"blocked, {summary}"
+        st.hints.extend(hints)
+        return st
+
+    secret = token(mirror)
+    if not secret:
+        return blocked(
+            f"no token for {mirror.host}",
+            "Set SPLENT_SOURCE_MIRROR_TOKEN, or log in with the GitHub CLI.",
+        )
+    try:
+        repository = registry.github_json(
+            f"{mirror.api_base}/repos/{mirror.org}/{mirror.repo}", secret
+        )
+    except (registry.RegistryError, ValueError) as e:
+        return blocked(f"{mirror.web_url} could not be asked ({e})")
+    if repository is None:
+        return blocked(f"{mirror.web_url} does not exist, or this token cannot see it")
+    if repository.get("archived"):
+        return blocked(f"{mirror.web_url} is archived")
+    if (repository.get("permissions") or {}).get("push") is False:
+        return blocked(f"this token cannot push to {mirror.web_url}")
+
+    try:
+        refs = _remote_refs(mirror, path)
+    except MirrorUnreachable as e:
+        return blocked(
+            f"git cannot reach {mirror.push_url} ({e})",
+            "The push goes over SSH, with the key this machine uses for the host.",
+        )
+    if f"refs/tags/{tag}" in refs:
+        return blocked(
+            f"{tag} is already there",
+            "Finish that version with splent release:resume, or release another.",
+        )
+    behind = [
+        branch
+        for branch in mirror.branches
+        if (sha := refs.get(f"refs/heads/{branch}"))
+        and not (
+            _have_commit(mirror, path, sha, branch) and _is_ancestor(path, sha, "HEAD")
+        )
+    ]
+    if behind:
+        names = ", ".join(behind)
+        return blocked(
+            f"{names} on {mirror.web_url} has commits this repository lacks",
+            "A branch only moves forward. Bring them in with "
+            f"git fetch {mirror.push_url} {behind[0]} && git merge FETCH_HEAD "
+            "(-s ours when this repository's tree is the one that stands).",
+        )
+    st.ok = True
+    st.summary = f"ready, {names_of(mirror)} and the release on {mirror.web_url}"
+    return st
+
+
+def names_of(mirror: SourceMirror) -> str:
+    return ", ".join(mirror.branches)
+
+
+def _branches_to_move(
+    mirror: SourceMirror, path: str, commit: str, refs: dict[str, str]
+) -> list[str]:
+    """The branches that do not hold *commit* yet."""
+    return [
+        branch
+        for branch in mirror.branches
+        if not (
+            (sha := refs.get(f"refs/heads/{branch}"))
+            and _have_commit(mirror, path, sha, branch)
+            and _is_ancestor(path, commit, sha)
+        )
+    ]
+
+
+def _local_commit(path: str, tag: str) -> str | None:
+    result = _git(
+        path, "rev-parse", "--verify", "--quiet", f"refs/tags/{tag}^{{commit}}"
+    )
+    return result.stdout.strip() if result.returncode == 0 else None
+
+
+def missing(mirror: SourceMirror, path: str, tag: str) -> list[str]:
+    """What the mirror still lacks of *tag*, as steps to show. Empty when complete.
+
+    Raises :class:`MirrorUnreachable` when it cannot tell.
+    """
+    refs = _remote_refs(mirror, path)
+    commit = _local_commit(path, tag)
+    steps = []
+    if commit is None:
+        move = list(mirror.branches)
+    else:
+        move = _branches_to_move(mirror, path, commit, refs)
+    if move:
+        steps.append(f"move {', '.join(move)} on {mirror.web_url} to {tag}")
+    if f"refs/tags/{tag}" not in refs:
+        steps.append(f"push the tag {tag} to {mirror.web_url}")
+    try:
+        existing = registry.github_json(
+            f"{mirror.api_base}/repos/{mirror.org}/{mirror.repo}/releases/tags/{tag}",
+            token(mirror),
+        )
+    except (registry.RegistryError, ValueError) as e:
+        raise MirrorUnreachable(str(e)) from e
+    if existing is None:
+        steps.append(f"create the release for {tag} on {mirror.web_url}")
+    return steps
+
+
+def _release_failure(result, mirror: SourceMirror) -> str:
+    if result.rate_limited:
+        return f"{mirror.host} is rate limiting this token (HTTP {result.status})"
+    if result.status == 401:
+        return f"{mirror.host} rejected the token (HTTP 401)"
+    if result.status == 403:
+        return f"this token cannot create releases on {mirror.web_url} (HTTP 403)"
+    return f"{mirror.host} answered HTTP {result.status} {result.detail}".strip()
+
+
+def publish(mirror: SourceMirror, path: str, tag: str) -> str | None:
+    """Bring *tag* to the mirror: branches, tag and release.
+
+    Does only what is missing, so running it again finishes it. Returns ``None``
+    on success and the reason on failure, for the caller to report once the
+    channels that can still finish have.
+    """
+    commit = _local_commit(path, tag)
+    if commit is None:
+        return f"there is no {tag} here to publish"
+    try:
+        refs = _remote_refs(mirror, path)
+        move = _branches_to_move(mirror, path, commit, refs)
+        refspecs = [f"{commit}:refs/heads/{branch}" for branch in move]
+        if f"refs/tags/{tag}" not in refs:
+            refspecs.append(f"refs/tags/{tag}:refs/tags/{tag}")
+        if refspecs:
+            # All of it or none of it: a tag without its branches, or the
+            # reverse, is the state this exists to avoid.
+            pushed = _git(path, "push", "--atomic", mirror.push_url, *refspecs)
+            if pushed.returncode != 0:
+                return pushed.stderr.strip() or "git push failed"
+    except (MirrorUnreachable, OSError, subprocess.TimeoutExpired) as e:
+        return str(e)
+    if move:
+        click.echo(f"  mirror   {names_of(mirror)} at {tag} on {mirror.web_url}")
+
+    secret = token(mirror)
+    if not secret:
+        return f"no token for {mirror.host}"
+    try:
+        result = registry.github_create_release(
+            mirror.org,
+            mirror.repo,
+            tag=tag,
+            name=f"{mirror.repo} {tag}",
+            body=(
+                "Released with [SPLENT](https://www.splent.io). The `deploy/` "
+                "directory of this tag holds what a server needs to run this "
+                "version.\n"
+            ),
+            token=secret,
+            api_base=mirror.api_base,
+            generate_notes=mirror.is_github,
+        )
+    except registry.RegistryError as e:
+        return f"{mirror.host} could not be reached ({e})"
+    if result.created:
+        click.echo(f"  mirror   release created {result.url or tag}")
+        return None
+    if result.already_exists:
+        click.secho(f"  mirror   release for {tag} already exists, kept", fg="yellow")
+        return None
+    return _release_failure(result, mirror)

{splent_cli-1.50.0 → splent_cli-1.51.0/src/splent_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: splent_cli
-Version: 1.50.0
+Version: 1.51.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.0 → splent_cli-1.51.0}/src/splent_cli.egg-info/SOURCES.txt

@@ -187,6 +187,7 @@ src/splent_cli/services/release.py
 src/splent_cli/services/release_dry_run.py
 src/splent_cli/services/release_gate.py
 src/splent_cli/services/security_scan.py
+src/splent_cli/services/source_mirror.py
 src/splent_cli/services/spl_store.py
 src/splent_cli/services/web_container.py
 src/splent_cli/templates/feature/feature_.gitignore.j2