funmirror 0.1.3__py3-none-any.whl

funmirror/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.1"

funmirror/mirror.py

@@ -0,0 +1,127 @@
+"""Single-repo mirror logic: skip-if-unchanged check, then clone + push."""
+
+import os
+import shutil
+import subprocess
+import tempfile
+import time
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional
+
+from farlog import get_logger
+
+from funmirror import platforms
+
+logger = get_logger("funmirror")
+
+
+@dataclass
+class MirrorContext:
+    github_org: str
+    gitee_org: str
+    gitee_token: str
+    gitee_key_file: str
+    github_token: str = ""
+    force: bool = True
+    workdir: str = field(default_factory=lambda: tempfile.mkdtemp(prefix="funmirror-"))
+
+
+@dataclass
+class MirrorResult:
+    repo: str
+    status: str  # "mirrored" | "skipped" | "failed"
+    detail: str = ""
+
+
+def _git_env(ctx: MirrorContext) -> Dict[str, str]:
+    env = os.environ.copy()
+    env["GIT_TERMINAL_PROMPT"] = "0"
+    env["GIT_SSH_COMMAND"] = (
+        f"ssh -i {ctx.gitee_key_file} -o StrictHostKeyChecking=no -o IdentitiesOnly=yes"
+    )
+    return env
+
+
+def _run(
+    cmd: List[str], *, cwd: Optional[str] = None, env: Optional[Dict[str, str]] = None
+):
+    return subprocess.run(
+        cmd, cwd=cwd, env=env, check=True, capture_output=True, text=True
+    )
+
+
+def _retry(fn, *args, attempts: int = 3, delay: float = 5, **kwargs):
+    last_exc: Optional[Exception] = None
+    for attempt in range(attempts):
+        try:
+            return fn(*args, **kwargs)
+        except Exception as exc:  # noqa: BLE001
+            last_exc = exc
+            if attempt < attempts - 1:
+                logger.warning(f"retry {attempt + 1}/{attempts} after error: {exc}")
+                time.sleep(delay * (2**attempt))
+    raise last_exc
+
+
+def mirror_one(repo: Dict, ctx: MirrorContext) -> MirrorResult:
+    name = repo["name"]
+    branch = repo.get("default_branch") or "master"
+
+    try:
+        src_sha = platforms.github_branch_sha(
+            ctx.github_org, name, branch, ctx.github_token
+        )
+
+        if platforms.gitee_repo_exists(ctx.gitee_org, name, ctx.gitee_token):
+            dst_sha = platforms.gitee_branch_sha(
+                ctx.gitee_org, name, branch, ctx.gitee_token
+            )
+        else:
+            logger.info(f"{name}: doesn't exist on Gitee, creating")
+            platforms.gitee_create_repo(ctx.gitee_org, name, ctx.gitee_token)
+            dst_sha = None
+
+        if src_sha and src_sha == dst_sha:
+            return MirrorResult(name, "skipped", "up to date")
+
+        return _clone_and_push(name, ctx, env=_git_env(ctx))
+    except Exception as exc:  # noqa: BLE001
+        logger.error(f"{name}: mirror failed: {exc}")
+        return MirrorResult(name, "failed", str(exc))
+
+
+def _clone_and_push(
+    name: str, ctx: MirrorContext, *, env: Dict[str, str]
+) -> MirrorResult:
+    repo_dir = os.path.join(ctx.workdir, name)
+    shutil.rmtree(repo_dir, ignore_errors=True)
+    try:
+        src_url = f"https://github.com/{ctx.github_org}/{name}.git"
+        if ctx.github_token:
+            src_url = f"https://x-access-token:{ctx.github_token}@github.com/{ctx.github_org}/{name}.git"
+
+        _retry(_run, ["git", "clone", "--quiet", src_url, repo_dir], env=env)
+        _run(["git", "remote", "set-head", "origin", "-d"], cwd=repo_dir, env=env)
+
+        rev = _run(
+            ["git", "rev-list", "-n", "1", "--all"], cwd=repo_dir, env=env
+        ).stdout.strip()
+        if not rev:
+            return MirrorResult(name, "skipped", "empty repo")
+
+        dst_url = f"git@gitee.com:{ctx.gitee_org}/{name}.git"
+        _run(["git", "remote", "add", "gitee", dst_url], cwd=repo_dir, env=env)
+        push_cmd = [
+            "git",
+            "push",
+            "gitee",
+            "refs/remotes/origin/*:refs/heads/*",
+            "--tags",
+            "--prune",
+        ]
+        if ctx.force:
+            push_cmd.append("-f")
+        _retry(_run, push_cmd, cwd=repo_dir, env=env)
+        return MirrorResult(name, "mirrored")
+    finally:
+        shutil.rmtree(repo_dir, ignore_errors=True)

funmirror/pipeline.py

@@ -0,0 +1,66 @@
+"""Parallel repo mirroring built on funworker's producer/processor/consumer pipeline."""
+
+from typing import Dict, List
+
+from farlog import get_logger
+from funworker import BaseConsumer, BaseProcessor, BaseProducer, Pipeline
+
+from funmirror.mirror import MirrorContext, MirrorResult, mirror_one
+
+logger = get_logger("funmirror")
+
+
+class RepoProducer(BaseProducer):
+    def __init__(self, *args, repos: List[Dict], **kwargs):
+        super().__init__(*args, **kwargs)
+        self._iter = iter(repos)
+
+    def produce(self):
+        return next(self._iter)
+
+
+class MirrorProcessor(BaseProcessor):
+    def __init__(self, ctx: MirrorContext):
+        self.ctx = ctx
+
+    def process(self, repo: Dict) -> MirrorResult:
+        return mirror_one(repo, self.ctx)
+
+
+class ResultConsumer(BaseConsumer):
+    def __init__(self, *args, total: int, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.total = total
+        self.done = 0
+        self.mirrored: List[str] = []
+        self.skipped: List[str] = []
+        self.failed: List[str] = []
+
+    def consume(self, result: MirrorResult) -> None:
+        self.done += 1
+        detail = f" ({result.detail})" if result.detail else ""
+        logger.info(
+            f"[{self.done}/{self.total}] {result.repo}: {result.status}{detail}"
+        )
+        bucket = {
+            "mirrored": self.mirrored,
+            "skipped": self.skipped,
+            "failed": self.failed,
+        }
+        bucket[result.status].append(result.repo)
+
+
+def run_mirror(
+    repos: List[Dict], ctx: MirrorContext, *, num_workers: int = 8
+) -> ResultConsumer:
+    """Mirror `repos` in parallel and return the consumer holding the final tallies."""
+    pipeline = Pipeline.build(
+        producer_cls=RepoProducer,
+        processor=lambda: MirrorProcessor(ctx),
+        consumer_cls=ResultConsumer,
+        num_workers=num_workers,
+        producer_kwargs={"repos": repos},
+        consumer_kwargs={"total": len(repos)},
+    )
+    pipeline.run()
+    return pipeline.consumer

funmirror/platforms.py

@@ -0,0 +1,96 @@
+"""GitHub / Gitee REST API helpers used by funmirror."""
+
+import time
+from typing import Dict, List, Optional
+
+import requests
+
+from farlog import get_logger
+
+logger = get_logger("funmirror")
+
+GITHUB_API = "https://api.github.com"
+GITEE_API = "https://gitee.com/api/v5"
+
+_session = requests.Session()
+
+
+def _github_headers(token: str) -> Dict[str, str]:
+    return {"Authorization": f"token {token}"} if token else {}
+
+
+def list_github_repos(org: str, token: str = "", per_page: int = 100) -> List[Dict]:
+    """List all repos in a GitHub org, with their default branch."""
+    repos: List[Dict] = []
+    page = 1
+    while True:
+        resp = _session.get(
+            f"{GITHUB_API}/orgs/{org}/repos",
+            params={"type": "all", "per_page": per_page, "page": page},
+            headers=_github_headers(token),
+            timeout=30,
+        )
+        resp.raise_for_status()
+        items = resp.json()
+        if not items:
+            break
+        repos.extend(
+            {"name": item["name"], "default_branch": item["default_branch"]}
+            for item in items
+        )
+        page += 1
+    return repos
+
+
+def github_default_branch(org: str, repo: str, token: str = "") -> Optional[str]:
+    resp = _session.get(
+        f"{GITHUB_API}/repos/{org}/{repo}", headers=_github_headers(token), timeout=30
+    )
+    if resp.status_code != 200:
+        return None
+    return resp.json().get("default_branch")
+
+
+def github_branch_sha(
+    org: str, repo: str, branch: str, token: str = ""
+) -> Optional[str]:
+    resp = _session.get(
+        f"{GITHUB_API}/repos/{org}/{repo}/branches/{branch}",
+        headers=_github_headers(token),
+        timeout=30,
+    )
+    if resp.status_code != 200:
+        return None
+    return resp.json().get("commit", {}).get("sha")
+
+
+def gitee_repo_exists(org: str, repo: str, token: str) -> bool:
+    resp = _session.get(
+        f"{GITEE_API}/repos/{org}/{repo}", params={"access_token": token}, timeout=30
+    )
+    return resp.status_code == 200
+
+
+def gitee_branch_sha(org: str, repo: str, branch: str, token: str) -> Optional[str]:
+    resp = _session.get(
+        f"{GITEE_API}/repos/{org}/{repo}/branches/{branch}",
+        params={"access_token": token},
+        timeout=30,
+    )
+    if resp.status_code != 200:
+        return None
+    return resp.json().get("commit", {}).get("sha")
+
+
+def gitee_create_repo(org: str, repo: str, token: str) -> None:
+    resp = _session.post(
+        f"{GITEE_API}/orgs/{org}/repos",
+        data={"name": repo, "access_token": token},
+        timeout=30,
+    )
+    if resp.status_code != 201:
+        raise RuntimeError(
+            f"failed to create {org}/{repo} on Gitee: {resp.status_code} {resp.text}"
+        )
+    # Gitee needs a moment before the new repo is ready to receive a push.
+    time.sleep(2)

funmirror/script.py

@@ -0,0 +1,117 @@
+"""funmirror CLI: mirror a GitHub org to a Gitee org."""
+
+import argparse
+import os
+import sys
+from typing import List
+
+from farlog import get_logger
+
+from funmirror import platforms
+from funmirror.mirror import MirrorContext
+from funmirror.pipeline import run_mirror
+
+logger = get_logger("funmirror")
+
+
+def _split_names(value: str) -> List[str]:
+    return [n.strip() for n in value.split(",") if n.strip()]
+
+
+def _build_repo_list(args: argparse.Namespace) -> List[dict]:
+    if args.repo_names:
+        names = _split_names(args.repo_names)
+        return [
+            {
+                "name": name,
+                "default_branch": platforms.github_default_branch(
+                    args.github_org, name, args.github_token
+                )
+                or "master",
+            }
+            for name in names
+        ]
+    return platforms.list_github_repos(args.github_org, args.github_token)
+
+
+def _mirror(args: argparse.Namespace) -> int:
+    repos = _build_repo_list(args)
+    if not repos:
+        logger.warning("No repos to mirror")
+        return 0
+
+    ctx = MirrorContext(
+        github_org=args.github_org,
+        gitee_org=args.gitee_org,
+        gitee_token=args.gitee_token,
+        gitee_key_file=args.gitee_key_file,
+        github_token=args.github_token,
+        force=args.force,
+    )
+
+    consumer = run_mirror(repos, ctx, num_workers=args.workers)
+
+    summary = (
+        f"Mirrored {len(consumer.mirrored)}, skipped {len(consumer.skipped)}, "
+        f"failed {len(consumer.failed)} (total {len(repos)})"
+    )
+    logger.info(summary)
+
+    step_summary = os.environ.get("GITHUB_STEP_SUMMARY")
+    if step_summary:
+        with open(step_summary, "a") as f:
+            f.write(summary + "\n")
+
+    github_output = os.environ.get("GITHUB_OUTPUT")
+    if github_output:
+        with open(github_output, "a") as f:
+            f.write(f"mirrored={len(consumer.mirrored)}\n")
+            f.write(f"skipped={len(consumer.skipped)}\n")
+            f.write(f"failed={len(consumer.failed)}\n")
+            f.write(f"total={len(repos)}\n")
+
+    if consumer.failed:
+        logger.error(f"Failed: {', '.join(consumer.failed)}")
+        return 1
+    return 0
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="funmirror", description="Mirror GitHub org repos to Gitee"
+    )
+    commands = parser.add_subparsers(dest="command", required=True)
+
+    mirror = commands.add_parser(
+        "mirror", help="mirror a GitHub org's repos to a Gitee org"
+    )
+    mirror.add_argument("--github-org", required=True)
+    mirror.add_argument("--gitee-org", required=True)
+    mirror.add_argument("--gitee-token", required=True)
+    mirror.add_argument("--gitee-key-file", required=True)
+    mirror.add_argument("--github-token", default="")
+    mirror.add_argument(
+        "--repo-names", default="", help="comma-separated; empty means all repos"
+    )
+    mirror.add_argument("--workers", type=int, default=8)
+    mirror.add_argument("--force", dest="force", action="store_true", default=True)
+    mirror.add_argument("--no-force", dest="force", action="store_false")
+    mirror.set_defaults(handler=_mirror)
+
+    return parser
+
+
+def funmirror() -> int:
+    args = _parser().parse_args()
+    try:
+        return args.handler(args)
+    except KeyboardInterrupt:
+        logger.warning("Interrupted")
+        return 1
+    except Exception as exc:  # noqa: BLE001
+        logger.exception(f"funmirror failed: {exc}")
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(funmirror())

funmirror-0.1.3.dist-info/METADATA

@@ -0,0 +1,81 @@
+Metadata-Version: 2.5
+Name: funmirror
+Version: 0.1.3
+Summary: Mirror GitHub organization repos to Gitee, in parallel, skipping repos that are already up to date
+Project-URL: Organization, https://github.com/farfarfun
+Project-URL: Repository, https://github.com/farfarfun/funmirror
+Project-URL: Releases, https://github.com/farfarfun/funmirror/releases
+Author-email: 牛哥 <niuliangtao@qq.com>, farfarfun <farfarfun@qq.com>
+Maintainer-email: 牛哥 <niuliangtao@qq.com>, farfarfun <farfarfun@qq.com>
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.9
+Requires-Dist: farlog>=1.1.8
+Requires-Dist: funworker>=0.0.1
+Requires-Dist: requests>=2.32.5
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# funmirror
+
+Mirror every repo in a GitHub organization to a Gitee organization, in
+parallel, skipping repos whose default branch hasn't changed since the last
+run.
+
+Built for [`farfarfun-action/mirror-to-gitee`](https://github.com/farfarfun-action/mirror-to-gitee),
+which is a thin wrapper around this package's CLI. It reproduces the core
+behavior of [`Yikun/hub-mirror-action`](https://github.com/Yikun/hub-mirror-action)
+(clone from GitHub, force-push `refs/remotes/origin/*:refs/heads/*` plus tags
+to Gitee) without depending on that action, and adds two things it doesn't
+have:
+
+- **Parallelism** — repos are mirrored concurrently via a
+  [`funworker`](https://github.com/farfarfun/funworker) pipeline
+  (`--workers`, default 8).
+- **Skip-if-unchanged** — before cloning anything, the latest commit sha of
+  the source and destination default branch is compared; if they already
+  match, the repo is skipped entirely.
+
+## Install
+
+```bash
+pip install "git+https://github.com/farfarfun/funmirror.git@v0.1.0"
+```
+
+## Usage
+
+```bash
+funmirror mirror \
+  --github-org my-org \
+  --gitee-org my-org \
+  --gitee-token "$GITEE_TOKEN" \
+  --gitee-key-file ~/.ssh/gitee_deploy_key \
+  --github-token "$GITHUB_TOKEN" \
+  --repo-names repo-a,repo-b \
+  --workers 8
+```
+
+`--repo-names` is optional; if omitted, every repo in `--github-org` is
+mirrored (requires `--github-token` to list them).
+
+Exit code is `1` if any repo failed to mirror; a one-line summary
+(`Mirrored X, skipped Y, failed Z (total N)`) is printed and, if
+`GITHUB_STEP_SUMMARY` is set, appended to it.
+
+## How a single repo is mirrored
+
+1. Look up the latest commit sha of the source default branch on GitHub.
+2. If the repo doesn't exist yet on Gitee, create it; otherwise look up the
+   latest commit sha of the same branch on Gitee.
+3. If both shas match, skip — nothing to do.
+4. Otherwise `git clone` from GitHub, then `git push` (force by default)
+   `refs/remotes/origin/*:refs/heads/*` plus tags to Gitee over SSH, with
+   retries.
+
+## Development
+
+```bash
+pip install -e ".[dev]"
+pytest
+```

funmirror-0.1.3.dist-info/RECORD

@@ -0,0 +1,10 @@
+funmirror/__init__.py,sha256=rnObPjuBcEStqSO0S6gsdS_ot8ITOQjVj_-P1LUUYpg,22
+funmirror/mirror.py,sha256=5t_8Dn1SsSEg3FGU8buP_-0IHn1QrLCAWRl349nVSNg,3946
+funmirror/pipeline.py,sha256=sQjLCdhaXEflTSjRUZqaKM-x-VGNWd2wIo3sOQK9Edo,2014
+funmirror/platforms.py,sha256=XpAVamePzpdIbdQGk4FZGyTCRB6qoLVvRLMb6SH-mpM,2805
+funmirror/script.py,sha256=eZ_5kL9gqLxQ5sL9osQfNYGu4wlcHu3ru2_8dJ_R-Cg,3552
+funmirror-0.1.3.dist-info/METADATA,sha256=NG_M4htSjLC3wEJzKoUHVvWN_WVPTs0FZmaa53eYsSc,2838
+funmirror-0.1.3.dist-info/WHEEL,sha256=THafob7ofN-NsuMN7Mg4qZyHaQI7KkD-QlcQatYhXPo,87
+funmirror-0.1.3.dist-info/entry_points.txt,sha256=ejpSk3gplMKiN6RrPi_L_vRJhU7786GMRd9nIrQkrV8,57
+funmirror-0.1.3.dist-info/licenses/LICENSE,sha256=BvvS-yeQjeaYgHQW2Vh7Msedpzoc-r7mnjNCpqUUbgM,1066
+funmirror-0.1.3.dist-info/RECORD,,

funmirror-0.1.3.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.3
+Root-Is-Purelib: true
+Tag: py3-none-any

funmirror-0.1.3.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+funmirror = funmirror.script:funmirror

funmirror-0.1.3.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 farfarfun
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.