github-rest-api 0.34.0__tar.gz → 0.35.0__tar.gz

github_rest_api-0.35.0/.github/workflows/create_pr_to_main.yml

@@ -0,0 +1,21 @@
+name: Create PR To main
+on:
+  push:
+    branches-ignore:
+      - main
+      - _**
+jobs:
+  create_pr_main:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Install uv
+        run: |
+          curl -LsSf https://astral.sh/uv/install.sh | sudo env UV_INSTALL_DIR="/usr/local/bin" sh
+      - name: Create PR To main
+        run: | 
+          curl -sSL https://raw.githubusercontent.com/legendu-net/github_actions_scripts/main/create_pull_request.py \
+            | uv run --script - \
+            --head-branch ${{ github.ref_name }} \
+            --base-branch main \
+            --token ${{ secrets.GITHUBACTIONS }}
+

{github_rest_api-0.34.0 → github_rest_api-0.35.0}/.github/workflows/lint.yml

@@ -1,10 +1,9 @@
 name: Lint Code
 
 on:
-  push:
-    branches: [ dev, main ]
   pull_request:
-    branches: [ dev ]
+    branches:
+      - main
 
 jobs:
   lint_code:
@@ -22,4 +21,4 @@ jobs:
     - name: Lint with Ty
       run: uv run ty check
     - name: Analyze Dependencies
-      run: uv run deptry .
+      run: uv run deptry .

github_rest_api-0.35.0/.github/workflows/remove_branch.yml

@@ -0,0 +1,19 @@
+name: Remove Branches
+on:
+  schedule:
+    - cron: '0 3 * * *'
+      timezone: 'America/Los_Angeles'
+jobs:
+  remove_branch:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Install uv
+        run: |
+          curl -LsSf https://astral.sh/uv/install.sh | sudo env UV_INSTALL_DIR="/usr/local/bin" sh
+      - name: Remove Branches
+        run: | 
+          curl -sSL https://raw.githubusercontent.com/legendu-net/github_actions_scripts/main/remove_branch.py \
+            | uv run --script - \
+            --repo ${{ github.repository }} \
+            --pattern '^(?!main$)' \
+            --token ${{ secrets.GITHUBACTIONS }}

github_rest_api-0.35.0/.github/workflows/test.yml

@@ -0,0 +1,25 @@
+name: Run Tests
+on:
+  pull_request:
+    branches:
+      - main
+jobs:
+  test_code:
+    runs-on: ${{matrix.os}}
+    strategy:
+      matrix:
+        os: 
+          - macOS-latest
+          - ubuntu-latest
+        python-version: 
+          - "3.12"
+          - "3.13"
+          - "3.14"
+    steps:
+    - uses: actions/checkout@v6
+    - name: Install dependencies
+      run: |
+        curl -LsSf https://astral.sh/uv/install.sh | sudo env UV_INSTALL_DIR="/usr/local/bin" sh
+        uv sync --all-extras
+    - name: Test with pytest
+      run: uv run --python ${{ matrix.python-version }} pytest

{github_rest_api-0.34.0 → github_rest_api-0.35.0}/.gitignore

@@ -19,3 +19,4 @@ dist/
 doc*/_build/
 *.prof
 core
+.claude/settings.local.json

{github_rest_api-0.34.0 → github_rest_api-0.35.0}/GEMINI.md

@@ -7,13 +7,16 @@ A simple Python wrapper for GitHub REST APIs, optimized for use in GitHub Action
 - **Purpose:** Provide a streamlined interface for interacting with GitHub's REST API
   and performing Git operations within automation scripts.
 - **Main Technologies:**
-  - **Python 3.11+**: Core language.
+  - **Python 3.12+**: Core language.
   - **requests**: For HTTP interactions with the GitHub API.
   - **dulwich**: A pure-Python implementation of Git for repository operations.
+  - **tenacity**: For retry logic on API requests.
+  - **tomli-w**: For writing TOML files.
   - **psutil**: For system and process utilities.
 - **Architecture:**
   - `github_rest_api/github.py`: Contains the `GitHub` class for handling API requests (GET, POST, DELETE, PUT, PATCH).
-  - `github_rest_api/actions/`: Focused utilities for GitHub Actions, including branch management and pushing changes.
+  - `github_rest_api/actions/github/`: Utilities for GitHub actions like creating pull requests, managing releases, and adding repositories.
+  - `github_rest_api/actions/container/`: Utilities for building and configuring container images.
   - `github_rest_api/actions/cargo/`: Specific support for Rust projects (benchmarking and profiling).
   - `github_rest_api/utils.py`: General-purpose utilities (versioning, partitioning).
 
@@ -28,6 +31,7 @@ This project uses `uv` for dependency and environment management.
 - **Code Formatting:**
   ```bash
   uv run ruff format ./
+  uv run pyproject-fmt pyproject.toml
   ```
 - **Linting:**
   ```bash
@@ -36,6 +40,7 @@ This project uses `uv` for dependency and environment management.
 - **Type Checking:**
   ```bash
   uv run ty check
+  uv run pyright
   ```
 - **Dependency Analysis:**
   ```bash
@@ -48,8 +53,8 @@ This project uses `uv` for dependency and environment management.
 
 ## Development Conventions
 
-- **Code Style:** Strictly follows `ruff` formatting and linting rules.
-- **Type Safety:** Uses `ty` (in addition to standard type hints) to ensure type correctness.
+- **Code Style:** Strictly follows `ruff` formatting and linting rules. `pyproject-fmt` is used for TOML formatting.
+- **Type Safety:** Uses `ty` and `pyright` to ensure type correctness.
 - **CI/CD:** Automated linting and formatting checks are performed
   on `push` to `dev`/`main` branches and on `pull_request` to `dev`.
 - **Git Operations:** Prefers `dulwich` for programmatic Git interactions

{github_rest_api-0.34.0 → github_rest_api-0.35.0}/PKG-INFO

@@ -1,17 +1,18 @@
 Metadata-Version: 2.4
 Name: github-rest-api
-Version: 0.34.0
+Version: 0.35.0
 Summary: Simple wrapper of GitHub REST APIs.
 Author-email: Ben Du <longendu@yahoo.com>
 Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
-Requires-Python: <4,>=3.11
+Requires-Python: <4,>=3.12
 Requires-Dist: dulwich>=0.25.1
 Requires-Dist: psutil>=5.9.4
 Requires-Dist: requests>=2.28.2
+Requires-Dist: tenacity>=9.1.4
+Requires-Dist: tomli-w>=1
 Description-Content-Type: text/markdown
 
 # GitHub REST APIs  |  [@GitHub](https://github.com/legendu-net/github_rest_api)  |  [@PyPI](https://pypi.org/project/github-rest-api/)

github_rest_api-0.35.0/github_rest_api/actions/container/__init__.py

@@ -0,0 +1 @@
+"""Container-related GitHub Actions scripts."""

github_rest_api-0.35.0/github_rest_api/actions/container/build_container_images.py

@@ -0,0 +1,232 @@
+import argparse
+import datetime
+from pathlib import Path
+import subprocess as sp
+import sys
+from typing import cast
+from dulwich.repo import Repo
+from dulwich.refs import Ref
+from dulwich.objects import Commit
+from dulwich.errors import NotGitRepository
+from dulwich.diff_tree import tree_changes
+from tenacity import retry, stop_after_attempt, wait_exponential
+
+
+def _get_commit(name: bytes) -> bytes:
+    """Resolve a commit SHA or branch name to a commit SHA string."""
+    repo = Repo(".")
+    if name in repo:
+        return name
+    for prefix in [b"refs/heads/", b"refs/remotes/origin/", b"refs/tags/"]:
+        ref = cast(Ref, prefix + name)
+        if ref in repo.refs:
+            return repo.refs[ref]
+    raise KeyError(f"Cannot resolve commit or branch: {name}")
+
+
+def changed_files_between(
+    commit1: bytes, commit2: bytes, name1: str = "", name2: str = ""
+) -> list[Path]:
+    """Get a unique list of changed files between 2 commits.
+
+    :param commit1: The first commit ID.
+    :param commit2: The second commit ID.
+    :param name1: Optional human-readable name for commit1 used in logging (defaults to the commit SHA).
+    :param name2: Optional human-readable name for commit2 used in logging (defaults to the commit SHA).
+    :return: A unique list of changed files.
+    """
+    repo = Repo(".")
+    c1 = cast(Commit, repo[commit1])
+    c2 = cast(Commit, repo[commit2])
+    changes = tree_changes(repo.object_store, c1.tree, c2.tree)
+    files = set()
+    for change in changes:
+        if change.old and change.old.path:
+            files.add(change.old.path.decode())
+        if change.new and change.new.path:
+            files.add(change.new.path.decode())
+    paths = sorted(Path(file) for file in files)
+    print(
+        f"Changed files between {name1 or commit1.decode()[:7]} and {
+            name2 or commit2.decode()[:7]
+        }:"
+    )
+    for p in paths:
+        print(f"  {p}")
+    return paths
+
+
+def has_relevant_changes(
+    commit1: str | bytes,
+    commit2: str | bytes,
+    image_dirs: list[str],
+    name1: str = "",
+    name2: str = "",
+) -> bool:
+    if not commit1 or not commit2:
+        return True
+    if isinstance(commit1, str):
+        commit1 = commit1.encode()
+    if isinstance(commit2, str):
+        commit2 = commit2.encode()
+    dirs = [Path(d).resolve() for d in image_dirs]
+    for p in changed_files_between(commit1, commit2, name1=name1, name2=name2):
+        if any(p.resolve().is_relative_to(d) for d in dirs):
+            return True
+    return False
+
+
+def has_relevant_changes_main_dev(image_dirs: list[str]) -> bool:
+    try:
+        c_main = _get_commit(b"main")
+        c_dev = _get_commit(b"dev")
+    except (KeyError, NotGitRepository):
+        return True
+    return has_relevant_changes(c_main, c_dev, image_dirs, name1="main", name2="dev")
+
+
+def _tag_date(tag: str) -> str:
+    """Suffix a tag with the current date as a 6-digit string.
+
+    :param tag: A tag of a Podman image.
+    :return: A new tag.
+    """
+    return tag + datetime.datetime.now(tz=datetime.timezone.utc).strftime("_%m%d%H")
+
+
+@retry(
+    stop=stop_after_attempt(3), wait=wait_exponential(multiplier=60, min=60, max=300)
+)
+def _push_image(image: str, tool: str = "podman"):
+    sp.run(
+        [tool, "push", image],
+        shell=False,
+        check=True,
+    )
+
+
+def _build_image(
+    image_dir: str,
+    tags: str | list[str],
+    tool: str = "podman",
+    registry: str = "quay.io/legendu",
+):
+    if isinstance(tags, str):
+        tags = [tags]
+    image = f"{registry}/{image_dir}"
+    print(f"\n\nBuilding the {tool} image {image}...", flush=True)
+    cmd = [tool, "build", image_dir]
+    for tag in tags:
+        cmd.append("-t")
+        cmd.append(f"{image}:{tag}")
+    sp.run(cmd, shell=False, check=True)
+    for tag in tags:
+        _push_image(f"{image}:{tag}", tool=tool)
+
+
+def build_images(
+    commit1: str,
+    commit2: str,
+    image_dirs: list[str],
+    tool: str = "podman",
+    registry: str = "quay.io/legendu",
+):
+    if not has_relevant_changes(commit1, commit2, image_dirs):
+        print(
+            f"Skip building {tool} images as there are no relevant changes between {
+                commit1
+            } and {commit2}.\n"
+        )
+        return
+    tags = ["next"]
+    if not has_relevant_changes_main_dev(image_dirs):
+        tags.append("latest")
+    tags.extend([_tag_date(tag) for tag in tags])
+    print(f"Building {tool} images using tags:", ", ".join(tags), "\n", flush=True)
+    failures = []
+    for image_dir in image_dirs:
+        try:
+            _build_image(image_dir, tags=tags, tool=tool, registry=registry)
+        except (sp.CalledProcessError, FileNotFoundError) as e:
+            print(f"Error building {image_dir}: {e}", flush=True)
+            failures.append(image_dir)
+    if failures:
+        sys.exit(f"\n\nError: failed to build images: {', '.join(failures)}\n")
+
+
+def parse_args():
+    """Parse command-line arguments.
+
+    :return: An object containing the parsed arguments.
+    """
+    parser = argparse.ArgumentParser(description="Build container images.")
+    parser.add_argument(
+        "-c1",
+        "--commit1",
+        dest="commit1",
+        default="",
+        help="The first commit ID (empty by default).",
+    )
+    parser.add_argument(
+        "-c2",
+        "--commit2",
+        dest="commit2",
+        default="",
+        help="The second commit ID (empty by default).",
+    )
+    parser.add_argument(
+        "-r",
+        "--registry",
+        dest="registry",
+        default="quay.io/legendu",
+        help="Container registry prefix (default: quay.io/legendu).",
+    )
+    parser.add_argument(
+        "-t",
+        "--tool",
+        dest="tool",
+        default="podman",
+        choices=["podman", "docker"],
+        help="Container tool to use for building and pushing images (default: podman).",
+    )
+    group = parser.add_mutually_exclusive_group(required=True)
+    group.add_argument(
+        "-i",
+        "--image-dirs",
+        dest="image_dirs",
+        nargs="+",
+        default=None,
+        metavar="IMAGE_DIR",
+        help="Explicit list of image directories to build.",
+    )
+    group.add_argument(
+        "-f",
+        "--file-image-dirs",
+        dest="file_image_dirs",
+        default=None,
+        metavar="FILE",
+        help="Path to a file listing image directories to build, one per line.",
+    )
+    return parser.parse_args()
+
+
+def _resolve_image_dirs(args: argparse.Namespace) -> list[str]:
+    if args.image_dirs:
+        return args.image_dirs
+    lines = Path(args.file_image_dirs).read_text().splitlines()
+    return [line.strip() for line in lines if line.strip()]
+
+
+def main():
+    args = parse_args()
+    build_images(
+        args.commit1,
+        args.commit2,
+        _resolve_image_dirs(args),
+        tool=args.tool,
+        registry=args.registry,
+    )
+
+
+if __name__ == "__main__":
+    main()

github_rest_api-0.35.0/github_rest_api/actions/container/config_container.py

@@ -0,0 +1,82 @@
+import argparse
+import json
+import shutil
+import tomllib
+import tomli_w
+from pathlib import Path
+import subprocess as sp
+
+
+def config_docker(data_root: str = "/mnt/docker"):
+    if not shutil.which("docker"):
+        print("Docker not found, skipping Docker configuration.")
+        return
+    Path(data_root).mkdir(parents=True, exist_ok=True)
+    sp.run(["systemctl", "stop", "docker"], check=True)
+    path = Path("/etc/docker/daemon.json")
+    settings: dict = {}
+    if path.is_file() and path.stat().st_size > 0:
+        with path.open("r", encoding="utf-8") as fin:
+            settings = json.load(fin)
+    settings["data-root"] = data_root
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("w", encoding="utf-8") as fout:
+        json.dump(settings, fout, indent=4)
+    print(settings)
+    sp.run(["systemctl", "start", "docker"], check=True)
+    sp.run(["docker", "info"], check=True)
+
+
+def config_podman(graphroot: str = "/mnt/podman"):
+    if not shutil.which("podman"):
+        print("Podman not found, skipping Podman configuration.")
+        return
+    Path(graphroot).mkdir(parents=True, exist_ok=True)
+    path = Path("/etc/containers/storage.conf")
+    settings: dict = {}
+    if path.is_file() and path.stat().st_size > 0:
+        with path.open("rb") as fin:
+            settings = tomllib.load(fin)
+    storage = settings.setdefault("storage", {})
+    storage["graphroot"] = graphroot
+    storage.setdefault("driver", "overlay")
+    storage.setdefault("runroot", "/run/containers/storage")
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("wb") as fout:
+        tomli_w.dump(settings, fout)
+    print(settings)
+    sp.run(["podman", "info"], check=True)
+
+
+def parse_args(args=None):
+    parser = argparse.ArgumentParser(description="Configure container runtimes.")
+    parser.add_argument(
+        "runtime",
+        nargs="*",
+        choices=["docker", "podman"],
+        help="Container runtime(s) to configure. Configures both if not specified.",
+    )
+    parser.add_argument(
+        "--docker-data-root",
+        default="/mnt/docker",
+        help="Docker data-root directory (default: /mnt/docker).",
+    )
+    parser.add_argument(
+        "--podman-graphroot",
+        default="/mnt/podman",
+        help="Podman graphroot directory (default: /mnt/podman).",
+    )
+    return parser.parse_args(args=args)
+
+
+def main():
+    args = parse_args()
+    runtimes = set(args.runtime) if args.runtime else {"docker", "podman"}
+    if "docker" in runtimes:
+        config_docker(args.docker_data_root)
+    if "podman" in runtimes:
+        config_podman(args.podman_graphroot)
+
+
+if __name__ == "__main__":
+    main()

github_rest_api-0.35.0/github_rest_api/actions/container/update_version_containerfile.py

@@ -0,0 +1,201 @@
+import argparse
+import datetime
+import os
+from pathlib import Path
+import re
+from dulwich import porcelain
+from github_rest_api import Repository
+from github_rest_api.utils import next_minor_or_strip_patch
+from requests.exceptions import HTTPError
+
+
+def parse_latest_version(repo: str) -> str:
+    r = Repository(token="", repo=repo)
+    try:
+        release = r.get_release_latest()
+        version = release["tag_name"]
+    except HTTPError as err:
+        if err.response is not None and err.response.status_code == 404:
+            tags = r.get_tags(n=1)
+            version = tags[0]["name"]
+        else:
+            raise err
+    version = version.replace("v", "")
+    print(f"The latest version of {repo} is v{version}.")
+    return version
+
+
+def update_version(
+    containerfile: str | Path, version: str, pattern: str, replace: str
+) -> None:
+    if containerfile == "":
+        containerfile = "Dockerfile" if Path("Dockerfile").exists() else "Containerfile"
+    if isinstance(containerfile, str):
+        containerfile = Path(containerfile).resolve()
+    match containerfile.parent.name:
+        case "docker-base":
+            return _update_version_docker_base(
+                containerfile=containerfile, version=version
+            )
+        case "docker-jupyterlab":
+            return _update_version_docker_jupyterlab(
+                containerfile=containerfile, version=version
+            )
+        case "docker-jupyterhub":
+            return _update_version_docker_jupyterhub(
+                containerfile=containerfile, version=version
+            )
+        case "docker-vscode-server":
+            return _update_version_docker_vscode_server(
+                containerfile=containerfile, version=version
+            )
+        case _:
+            if not pattern:
+                raise ValueError("A version pattern must be specified!")
+            return _update_version_default(
+                containerfile=containerfile,
+                version=version,
+                pattern=pattern,
+                replace=replace,
+            )
+
+
+def _update_version_default(
+    containerfile: Path, version: str, pattern: str, replace: str
+) -> None:
+    text = containerfile.read_text()
+    text = re.sub(pattern, replace.format(version=version), text)
+    containerfile.write_text(text)
+
+
+def _update_version_docker_base(containerfile: Path, version: str) -> None:
+    _update_version_default(
+        containerfile=containerfile,
+        version=version,
+        pattern=r"-v v?\d+\.\d+\.\d+",
+        replace="-v v{version}",
+    )
+
+
+def _update_version_docker_jupyterlab(containerfile: Path, version: str) -> None:
+    version = next_minor_or_strip_patch(version, 3)
+    _update_version_default(
+        containerfile=containerfile,
+        version=version,
+        pattern=r",<\d+\.\d+\.0",
+        replace=",<{version}",
+    )
+
+
+def _update_version_docker_jupyterhub(containerfile: Path, version: str) -> None:
+    version = next_minor_or_strip_patch(version, 3)
+    _update_version_default(
+        containerfile=containerfile,
+        version=version,
+        pattern=r"jupyterhub<\d+\.\d+\.0",
+        replace="jupyterhub<{version}",
+    )
+
+
+def _update_version_docker_vscode_server(containerfile: Path, version: str) -> None:
+    version = next_minor_or_strip_patch(version, 3)
+    _update_version_default(
+        containerfile=containerfile,
+        version=version,
+        pattern=r",<\d+\.\d+\.0",
+        replace=",<{version}",
+    )
+
+
+def _branch_prefix(repo: str) -> str:
+    return repo.replace("/", "_") + "_version"
+
+
+def push_changes(repo: str, token: str):
+    if not porcelain.status().unstaged:
+        print("No changes!")
+        return
+    porcelain.add()
+    porcelain.commit(message=f"update version of {repo}")
+    gh_repo = os.environ["GITHUB_REPOSITORY"]
+    porcelain.push(
+        repo=".",
+        remote_location=f"https://github.com/{gh_repo}.git",
+        username="x-access-token",
+        password=token,
+    )
+
+
+def parse_args():
+    """Parse command-line arguments."""
+    parser = argparse.ArgumentParser(
+        description="Update the version of a package in a Dockerfile or Containerfile."
+    )
+    parser.add_argument(
+        "--containerfile",
+        dest="containerfile",
+        default="",
+        help="The Dockerfile or Containerfile to update.",
+    )
+    parser.add_argument(
+        "--token",
+        dest="token",
+        required=True,
+        help="A GitHub token for the repo to be updated.",
+    )
+    parser.add_argument(
+        "--repo",
+        dest="repo",
+        required=True,
+        help="The GitHub repo (in the format of owner/repo) whose release versions are watched.",
+    )
+    parser.add_argument(
+        "--pattern",
+        dest="pattern",
+        default="",
+        help="The version pattern to replace.",
+    )
+    parser.add_argument(
+        "--replace",
+        dest="replace",
+        default="",
+        help="The replacement for the matched version pattern.",
+    )
+    return parser.parse_args()
+
+
+def has_open_pr(head_prefix: str) -> bool:
+    """Check if there's an open PR whose head starts with head_prefix.
+
+    :param head_prefix: The prefix of head to check for.
+    """
+    prs = Repository(token="", repo=os.environ["GITHUB_REPOSITORY"]).get_pull_requests()
+    for pr in prs:
+        if pr["head"]["ref"].startswith(head_prefix):
+            return True
+    return False
+
+
+def checkout_branch(repo: str):
+    branch = _branch_prefix(repo) + datetime.date.today().strftime("_%Y%m%d")
+    porcelain.branch_create(repo=".", name=branch)
+    porcelain.checkout(repo=".", target=branch)
+
+
+def main():
+    args = parse_args()
+    if has_open_pr(head_prefix=_branch_prefix(args.repo)):
+        return
+    checkout_branch(args.repo)
+    version = parse_latest_version(repo=args.repo)
+    update_version(
+        containerfile=args.containerfile,
+        version=version,
+        pattern=args.pattern,
+        replace=args.replace,
+    )
+    push_changes(repo=args.repo, token=args.token)
+
+
+if __name__ == "__main__":
+    main()

github_rest_api-0.35.0/github_rest_api/actions/github/__init__.py

@@ -0,0 +1 @@
+"""GitHub-related Actions scripts."""