git-buckets 0.3.1__tar.gz → 0.4.0__tar.gz

{git_buckets-0.3.1 → git_buckets-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: git-buckets
-Version: 0.3.1
+Version: 0.4.0
 Summary: Git over S3: clone, fetch and push repositories backed by an S3 bucket.
 Author: Full Duplex Media
 Author-email: Full Duplex Media <contact@fullduplex.media>
@@ -123,6 +123,19 @@ gb repo delete my-bucket/tools/cli/my-project --yes  # without --yes it only pri
 Delete takes the repo's LFS objects, locks, bundles, packages and rendered web tree with it. The undo path is S3
 versioning on the operator's side, not a `gb` command. There is no rename.
 
+## Package lifecycle
+
+Published files are immutable, so a bad release is yanked rather than replaced: it stays downloadable for anything
+that already pinned it, and every other resolve skips it.
+
+```sh
+gb package list                                          # every bucket, grouped by repo
+gb package list -b my-bucket -r tools/cli/my-project     # one repo; -v lists every file with size and sha256
+gb package yank my-bucket/tools/cli/my-project my-project 1.2.0 --reason "bad wheel"
+gb package unyank my-bucket/tools/cli/my-project my-project 1.2.0
+gb package delete my-bucket/tools/cli/my-project my-project 1.2.0 --yes  # the bytes go; lockfiles that pin it 404
+```
+
 ## Where the secrets live
 
 The refresh token (one year, fixed from sign-in) goes in your OS keyring, or in `~/.config/gb/hosts.yml` at 0600 when no

{git_buckets-0.3.1 → git_buckets-0.4.0}/README.md

@@ -108,6 +108,19 @@ gb repo delete my-bucket/tools/cli/my-project --yes  # without --yes it only pri
 Delete takes the repo's LFS objects, locks, bundles, packages and rendered web tree with it. The undo path is S3
 versioning on the operator's side, not a `gb` command. There is no rename.
 
+## Package lifecycle
+
+Published files are immutable, so a bad release is yanked rather than replaced: it stays downloadable for anything
+that already pinned it, and every other resolve skips it.
+
+```sh
+gb package list                                          # every bucket, grouped by repo
+gb package list -b my-bucket -r tools/cli/my-project     # one repo; -v lists every file with size and sha256
+gb package yank my-bucket/tools/cli/my-project my-project 1.2.0 --reason "bad wheel"
+gb package unyank my-bucket/tools/cli/my-project my-project 1.2.0
+gb package delete my-bucket/tools/cli/my-project my-project 1.2.0 --yes  # the bytes go; lockfiles that pin it 404
+```
+
 ## Where the secrets live
 
 The refresh token (one year, fixed from sign-in) goes in your OS keyring, or in `~/.config/gb/hosts.yml` at 0600 when no

{git_buckets-0.3.1 → git_buckets-0.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "git-buckets"
-version = "0.3.1"
+version = "0.4.0"
 description = "Git over S3: clone, fetch and push repositories backed by an S3 bucket."
 readme = "README.md"
 requires-python = ">=3.14"

{git_buckets-0.3.1 → git_buckets-0.4.0}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "git-buckets"
-version = "0.3.1"
+version = "0.4.0"
 description = "Git over S3: clone, fetch and push repositories backed by an S3 bucket."
 authors = [
   { name = 'Full Duplex Media', email = 'contact@fullduplex.media' }

{git_buckets-0.3.1 → git_buckets-0.4.0}/src/git_buckets/cli.py

@@ -231,6 +231,125 @@ def repo_unprotect_command(name: str, ref: str, host: str | None) -> None:
     _protect('unprotect', name, ref, host)
 
 
+@cli.group(name='package')
+def package_group() -> None:
+    """Manage published packages: list them, yank a bad release, delete one."""
+
+
+def _print_versions(versions: list[dict], verbose: bool) -> None:
+    for release in versions:
+        yanked = release.get('yanked')
+        suffix = f'  (yanked: {yanked})' if isinstance(yanked, str) and yanked else '  (yanked)' if yanked else ''
+        # A file whose name declares no version still lists, grouped under a null version by the API.
+        version = release.get('version') or '(unversioned)'
+        click.echo(f'    {version}{suffix}')
+        if verbose:
+            for entry in release.get('files', []):
+                click.echo(f'      {entry["filename"]}  {_human_bytes(entry["size"])}  {entry["sha256"]}')
+
+
+@package_group.command(name='list')
+@_HOST_OPTION
+@click.option('-b', '--bucket', default=None, help='One bucket; every bucket you can see if omitted.')
+@click.option('-r', '--repo', 'repo_path', default=None, help='One repo inside the bucket; needs --bucket.')
+@click.option('-v', '--verbose', is_flag=True, help='Also list every file with its size and sha256.')
+@click.argument('name', required=False)
+def package_list_command(
+    host: str | None, bucket: str | None, repo_path: str | None, verbose: bool, name: str | None
+) -> None:
+    """List published packages: gb package list [-b BUCKET] [-r REPO] [NAME]."""
+    from . import package as package_module, repo as repo_module
+
+    if repo_path and not bucket:
+        raise click.UsageError('--repo needs --bucket: packages live in a bucket, and repo paths are not unique.')
+    try:
+        domain, entry = repo_module.select_host(host)
+        labels = [bucket] if bucket else package_module.buckets(domain, entry)
+        listings = [(label, package_module.listing(domain, entry, label, repo_path, name)) for label in labels]
+    except Exception as x:
+        raise click.ClickException(str(x)) from None
+    if not listings:
+        click.echo('No buckets. Run: gb login <deployment-domain>')
+        return
+    for label, packages in listings:
+        click.echo(label)
+        if not packages:
+            click.echo('  (no packages)')
+        for project in sorted(packages, key=lambda item: (item['repo'], item['name'])):
+            click.echo(f'  {project["repo"]}  {project["name"]}')
+            _print_versions(project.get('versions', []), verbose)
+
+
+@package_group.command(name='yank')
+@_HOST_OPTION
+@click.option('--reason', default=None, help='Why it was yanked; resolvers and gb package list show it.')
+@click.argument('repo_name', metavar='BUCKET/REPO')
+@click.argument('package', metavar='NAME')
+@click.argument('version')
+def package_yank_command(repo_name: str, package: str, version: str, host: str | None, reason: str | None) -> None:
+    """Yank a release.
+
+    The files stay downloadable, so anything that already pinned the version keeps resolving; every other
+    resolve skips it.
+    """
+    from . import package as package_module, repo as repo_module
+
+    try:
+        bucket, path = repo_module.parse_name(repo_name)
+        domain, entry = repo_module.select_host(host)
+        result = package_module.yank(domain, entry, bucket, path, package, version, reason)
+    except Exception as x:
+        raise click.ClickException(str(x)) from None
+    click.echo(f'Yanked {package} {version} in {repo_name}: {len(result.get("files", []))} file(s).')
+
+
+@package_group.command(name='unyank')
+@_HOST_OPTION
+@click.argument('repo_name', metavar='BUCKET/REPO')
+@click.argument('package', metavar='NAME')
+@click.argument('version')
+def package_unyank_command(repo_name: str, package: str, version: str, host: str | None) -> None:
+    """Put a yanked release back."""
+    from . import package as package_module, repo as repo_module
+
+    try:
+        bucket, path = repo_module.parse_name(repo_name)
+        domain, entry = repo_module.select_host(host)
+        result = package_module.unyank(domain, entry, bucket, path, package, version)
+    except Exception as x:
+        raise click.ClickException(str(x)) from None
+    click.echo(f'Unyanked {package} {version} in {repo_name}: {len(result.get("files", []))} file(s).')
+
+
+@package_group.command(name='delete')
+@_HOST_OPTION
+@click.option('--yes', is_flag=True, help='Actually delete; without it, nothing is touched.')
+@click.argument('repo_name', metavar='BUCKET/REPO')
+@click.argument('package', metavar='NAME')
+@click.argument('version')
+def package_delete_command(repo_name: str, package: str, version: str, host: str | None, yes: bool) -> None:
+    """Delete a release's files."""
+    from . import package as package_module, repo as repo_module
+
+    try:
+        bucket, path = repo_module.parse_name(repo_name)
+        domain, entry = repo_module.select_host(host)
+    except Exception as x:
+        raise click.ClickException(str(x)) from None
+    if not yes:
+        click.echo(f'This deletes {package} {version} from {repo_name}. Lockfiles that pin it will 404.')
+        click.echo('Prefer `gb package yank` unless the bytes must not exist.')
+        raise click.ClickException('refusing to delete without confirmation; re-run with --yes')
+    try:
+        result = package_module.delete(domain, entry, bucket, path, package, version)
+    except Exception as x:
+        raise click.ClickException(str(x)) from None
+    deleted = result.get('deleted', [])
+    click.echo(f'Deleted {package} {version} from {repo_name}: {len(deleted)} file(s).')
+    for filename in deleted:
+        click.echo(f'  {filename}')
+
+
 @cli.command(name='credential', hidden=True)
 @click.argument('operation')
 def credential_command(operation: str) -> None:

git_buckets-0.4.0/src/git_buckets/package.py

@@ -0,0 +1,74 @@
+"""``gb package``: list, yank/unyank and delete releases against a deployment's package API.
+
+Click-free like :mod:`repo`, and deliberately built on its helpers: host selection, the session cookie and the
+error mapping are the same ones ``/api/repo/*`` uses, so :class:`~.repo.RepoError` is the error type here too.
+"""
+
+import re
+from typing import Any
+from urllib.parse import urlencode
+
+from . import net
+from .hosts import Entry
+from .repo import RepoError, _headers, _raise_mapped, list_repos
+
+
+def normalize(name: str) -> str:
+    """The PEP 503 normalized project name, which is what the index is keyed by."""
+    return re.sub(r'[-_.]+', '-', name).lower()
+
+
+def buckets(domain: str, entry: Entry) -> list[str]:
+    """Every bucket label the token can see. ``/api/packages`` is per bucket, so listing them all starts here."""
+    listing = list_repos(domain, entry)
+    return sorted({bucket['bucket'] for bucket in listing.get('buckets', [])})
+
+
+def listing(domain: str, entry: Entry, bucket: str, repo: str | None = None, name: str | None = None) -> list[Any]:
+    query: dict[str, str] = {'bucket': bucket}
+    if repo:
+        query['repo'] = repo
+    if name:
+        query['name'] = normalize(name)
+    url = f'https://{domain}/api/packages?{urlencode(query)}'
+    try:
+        result = net.get_json(url, headers=_headers(domain, entry))
+    except net.HttpError as x:
+        if x.status == 404:
+            raise RepoError(f'{bucket} is not a bucket on {domain}') from None
+        if x.status == 403:
+            raise RepoError(f'not entitled to list packages in {bucket}') from None
+        _raise_mapped(domain, x)
+        raise
+    return result.get('packages', [])
+
+
+def _call(
+    operation: str, domain: str, entry: Entry, bucket: str, repo: str, name: str, version: str, **extra: str
+) -> dict[str, Any]:
+    payload: dict[str, Any] = {'bucket': bucket, 'repo': repo, 'name': normalize(name), 'version': version, **extra}
+    try:
+        return net.post_json(f'https://{domain}/api/package/{operation}', payload, headers=_headers(domain, entry))
+    except net.HttpError as x:
+        if x.status == 403:
+            raise RepoError(f'not entitled to {operation} packages in {bucket}/{repo}') from None
+        if x.status == 404:
+            state = 'is not yanked in' if operation == 'unyank' else 'not found in'
+            raise RepoError(f'{name} {version} {state} {bucket}/{repo} on {domain}') from None
+        _raise_mapped(domain, x)
+        raise
+
+
+def yank(
+    domain: str, entry: Entry, bucket: str, repo: str, name: str, version: str, reason: str | None = None
+) -> dict[str, Any]:
+    extra = {'reason': reason} if reason else {}
+    return _call('yank', domain, entry, bucket, repo, name, version, **extra)
+
+
+def unyank(domain: str, entry: Entry, bucket: str, repo: str, name: str, version: str) -> dict[str, Any]:
+    return _call('unyank', domain, entry, bucket, repo, name, version)
+
+
+def delete(domain: str, entry: Entry, bucket: str, repo: str, name: str, version: str) -> dict[str, Any]:
+    return _call('delete', domain, entry, bucket, repo, name, version)