stardown 0.3.0__tar.gz

stardown-0.3.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 wydyippee
+
+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.

stardown-0.3.0/PKG-INFO

@@ -0,0 +1,143 @@
+Metadata-Version: 2.4
+Name: stardown
+Version: 0.3.0
+Summary: StarDown (GitHub Starred Downloader) — async fetch with rich live progress
+Author: wydyippee
+License: MIT
+Project-URL: Homepage, https://github.com/wydyippee/StarDown
+Project-URL: Repository, https://github.com/wydyippee/StarDown
+Project-URL: Issues, https://github.com/wydyippee/StarDown/issues
+Keywords: github,stars,backup,downloader,archive
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Utilities
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx>=0.27
+Requires-Dist: rich>=13
+Provides-Extra: linux
+Requires-Dist: uvloop>=0.19; extra == "linux"
+Provides-Extra: test
+Requires-Dist: pytest>=8; extra == "test"
+Dynamic: license-file
+
+<div align="center">
+
+# ★ StarDown ★
+
+**Stars, on your disk, fast.**
+
+[![Python](https://img.shields.io/badge/Python-3.11%2B-blue?style=flat-square&logo=python&logoColor=white)](https://www.python.org/)
+[![License](https://img.shields.io/badge/License-MIT-green?style=flat-square)](LICENSE)
+
+_List and bulk-download everything you've ever starred — with live progress bars that don't suck._
+
+</div>
+
+---
+
+## Why StarDown?
+
+Stars are bookmarks. Bookmarks rot. Repos get deleted, renamed, DMCA'd, or force-pushed into oblivion. **StarDown turns your star list into a local archive** — snapshots or full git clones, pulled down in parallel with a gorgeous live dashboard.
+
+- ⚡ **Async engine** — one shared HTTP session, bounded concurrency, 128 KiB streaming chunks, atomic writes, auto-resume
+- 📊 **Rich live progress** — per-repo bars with speed + ETA, plus a global counter (plain fallback in pipes/CI)
+- 🎯 **Two download modes** — `tar` snapshots (fast, tiny) or `git` clones (full history)
+- 🔎 **Filter before you pull** — by language, topic, search text, forks, archived
+- 🔑 **Auth-aware** — token support for private stars + 30x the rate limit
+- 🪶 **Zero friction** — one command install, double-click launchers included
+
+## Install
+
+```sh
+pip install -e .
+```
+
+That's it. You now own the `stardown` command everywhere.
+
+> No install? No problem — use the zero-setup launchers (they fetch deps on first run):
+>
+> ```bat
+> .\run.bat download --user octocat
+> ```
+>
+> ```sh
+> ./run.sh download --user octocat
+> ```
+
+## Quickstart
+
+```sh
+# Peek at your stars in a pretty table
+stardown list --user octocat
+
+# Archive them all — fast snapshots, 16 at a time
+stardown download --user octocat --out stars
+
+# Just your Python CLI obsessions, as JSON
+stardown list --user octocat --language python --topic cli --format json --out stars.json
+
+# Your own stars via token (also unlocks private repos)
+export GH_TOKEN=ghp_...
+stardown download --me --out stars
+```
+
+## Usage
+
+```n/a
+stardown list --user NAME [--me] [--language LANG] [--topic TOPIC]
+              [--search TEXT] [--no-forks] [--no-archived] [--limit N]
+              [--format table|json|csv] [--out FILE]
+
+stardown download --user NAME [--out DIR] [--method tar|git]
+                  [--workers 16] [--keep-tar] [--no-extract] [--force]
+                  [--ssh] [--full] [--no-progress] [filters...]
+```
+
+| Flag                          | What it does                                                                 |
+| ----------------------------- | ---------------------------------------------------------------------------- |
+| `--method tar` _(default)_    | Snapshot archives via the API — 5–10x faster, no `.git` weight               |
+| `--method git`                | Real clones (`--depth 1` unless `--full`), reruns `pull --ff-only` to update |
+| `--workers N`                 | Parallel downloads (default 16, max 64)                                      |
+| `--keep-tar` / `--no-extract` | Keep the `.tar.gz` files / skip extracting                                   |
+| `--force`                     | Re-download even if already cached (`.stardown-done` marker)                 |
+| `--no-progress`               | Plain output for scripts and CI                                              |
+
+Auth: you probably don't need to think about it. StarDown takes `--token` if you hand it one, else `$GH_TOKEN`, else it quietly checks your `gh` login and git's own credential store — and tells you when it finds something. No login anywhere? It goes anonymous (60 API calls/hr instead of 5,000). `--no-auto-auth` skips the snooping.
+
+## Under the hood
+
+- Single `httpx.AsyncClient` with keepalive reuse (fewer handshakes, fewer FDs)
+- `Semaphore`-bounded concurrency — fast without tripping `EMFILE`
+- Crash-safe writes: stream to `.part`, resume with `Range`, atomic `os.replace` on completion
+- Blocking tar extraction offloaded to a thread so the event loop never stalls
+- `uvloop` auto-engaged on Linux when installed (`pip install -e .[linux]`)
+- Sync `git` path kept in `clone.py` as the simple fallback
+
+## Dev
+
+```sh
+pip install -e .[test]
+python -m pytest tests/ -q
+```
+
+```n/a
+src/stardown/      api.py · async_download.py · clone.py · cli.py · ui.py
+tests/             offline unit tests (no network)
+run.bat · run.sh   zero-install launchers
+```
+
+## Credits
+
+Built by [**wydyippee**](https://github.com/wydyippee) ★ — for folk who star first and read later.
+
+## License
+
+MIT — see [LICENSE](LICENSE). StarDown save your sources? Smash that star. 🌟

stardown-0.3.0/README.md

@@ -0,0 +1,113 @@
+<div align="center">
+
+# ★ StarDown ★
+
+**Stars, on your disk, fast.**
+
+[![Python](https://img.shields.io/badge/Python-3.11%2B-blue?style=flat-square&logo=python&logoColor=white)](https://www.python.org/)
+[![License](https://img.shields.io/badge/License-MIT-green?style=flat-square)](LICENSE)
+
+_List and bulk-download everything you've ever starred — with live progress bars that don't suck._
+
+</div>
+
+---
+
+## Why StarDown?
+
+Stars are bookmarks. Bookmarks rot. Repos get deleted, renamed, DMCA'd, or force-pushed into oblivion. **StarDown turns your star list into a local archive** — snapshots or full git clones, pulled down in parallel with a gorgeous live dashboard.
+
+- ⚡ **Async engine** — one shared HTTP session, bounded concurrency, 128 KiB streaming chunks, atomic writes, auto-resume
+- 📊 **Rich live progress** — per-repo bars with speed + ETA, plus a global counter (plain fallback in pipes/CI)
+- 🎯 **Two download modes** — `tar` snapshots (fast, tiny) or `git` clones (full history)
+- 🔎 **Filter before you pull** — by language, topic, search text, forks, archived
+- 🔑 **Auth-aware** — token support for private stars + 30x the rate limit
+- 🪶 **Zero friction** — one command install, double-click launchers included
+
+## Install
+
+```sh
+pip install -e .
+```
+
+That's it. You now own the `stardown` command everywhere.
+
+> No install? No problem — use the zero-setup launchers (they fetch deps on first run):
+>
+> ```bat
+> .\run.bat download --user octocat
+> ```
+>
+> ```sh
+> ./run.sh download --user octocat
+> ```
+
+## Quickstart
+
+```sh
+# Peek at your stars in a pretty table
+stardown list --user octocat
+
+# Archive them all — fast snapshots, 16 at a time
+stardown download --user octocat --out stars
+
+# Just your Python CLI obsessions, as JSON
+stardown list --user octocat --language python --topic cli --format json --out stars.json
+
+# Your own stars via token (also unlocks private repos)
+export GH_TOKEN=ghp_...
+stardown download --me --out stars
+```
+
+## Usage
+
+```n/a
+stardown list --user NAME [--me] [--language LANG] [--topic TOPIC]
+              [--search TEXT] [--no-forks] [--no-archived] [--limit N]
+              [--format table|json|csv] [--out FILE]
+
+stardown download --user NAME [--out DIR] [--method tar|git]
+                  [--workers 16] [--keep-tar] [--no-extract] [--force]
+                  [--ssh] [--full] [--no-progress] [filters...]
+```
+
+| Flag                          | What it does                                                                 |
+| ----------------------------- | ---------------------------------------------------------------------------- |
+| `--method tar` _(default)_    | Snapshot archives via the API — 5–10x faster, no `.git` weight               |
+| `--method git`                | Real clones (`--depth 1` unless `--full`), reruns `pull --ff-only` to update |
+| `--workers N`                 | Parallel downloads (default 16, max 64)                                      |
+| `--keep-tar` / `--no-extract` | Keep the `.tar.gz` files / skip extracting                                   |
+| `--force`                     | Re-download even if already cached (`.stardown-done` marker)                 |
+| `--no-progress`               | Plain output for scripts and CI                                              |
+
+Auth: you probably don't need to think about it. StarDown takes `--token` if you hand it one, else `$GH_TOKEN`, else it quietly checks your `gh` login and git's own credential store — and tells you when it finds something. No login anywhere? It goes anonymous (60 API calls/hr instead of 5,000). `--no-auto-auth` skips the snooping.
+
+## Under the hood
+
+- Single `httpx.AsyncClient` with keepalive reuse (fewer handshakes, fewer FDs)
+- `Semaphore`-bounded concurrency — fast without tripping `EMFILE`
+- Crash-safe writes: stream to `.part`, resume with `Range`, atomic `os.replace` on completion
+- Blocking tar extraction offloaded to a thread so the event loop never stalls
+- `uvloop` auto-engaged on Linux when installed (`pip install -e .[linux]`)
+- Sync `git` path kept in `clone.py` as the simple fallback
+
+## Dev
+
+```sh
+pip install -e .[test]
+python -m pytest tests/ -q
+```
+
+```n/a
+src/stardown/      api.py · async_download.py · clone.py · cli.py · ui.py
+tests/             offline unit tests (no network)
+run.bat · run.sh   zero-install launchers
+```
+
+## Credits
+
+Built by [**wydyippee**](https://github.com/wydyippee) ★ — for folk who star first and read later.
+
+## License
+
+MIT — see [LICENSE](LICENSE). StarDown save your sources? Smash that star. 🌟

stardown-0.3.0/pyproject.toml

@@ -0,0 +1,43 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "stardown"
+version = "0.3.0"
+description = "StarDown (GitHub Starred Downloader) — async fetch with rich live progress"
+readme = "README.md"
+requires-python = ">=3.11"
+authors = [{name = "wydyippee"}]
+license = {text = "MIT"}
+keywords = ["github", "stars", "backup", "downloader", "archive"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Utilities",
+]
+dependencies = [
+    "httpx>=0.27",
+    "rich>=13",
+]
+
+[project.urls]
+Homepage = "https://github.com/wydyippee/StarDown"
+Repository = "https://github.com/wydyippee/StarDown"
+Issues = "https://github.com/wydyippee/StarDown/issues"
+
+[project.optional-dependencies]
+linux = ["uvloop>=0.19"]
+test = ["pytest>=8"]
+
+[project.scripts]
+stardown = "stardown.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["."]

stardown-0.3.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

stardown-0.3.0/stardown/__init__.py

@@ -0,0 +1,4 @@
+"""StarDown — back up your GitHub stars before they rot."""
+
+__version__ = "0.3.0"
+__all__ = ["__version__"]

stardown-0.3.0/stardown/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

stardown-0.3.0/stardown/api.py

@@ -0,0 +1,121 @@
+"""GitHub API calls. Sync stdlib, on purpose.
+
+Listing stars is a handful of paginated GETs per run — nothing that justifies
+an async client here. The hot path (streaming tarballs) lives in
+async_download.py.
+"""
+
+import json
+import urllib.error
+import urllib.request
+
+API = "https://api.github.com"
+
+
+def _headers(token=None):
+    headers = {
+        "Accept": "application/vnd.github+json",
+        "User-Agent": "StarDown/0.3.0",
+        "X-GitHub-Api-Version": "2022-11-28",
+    }
+    if token:
+        headers["Authorization"] = f"Bearer {token}"
+    return headers
+
+
+def _get_json(url, token, timeout):
+    req = urllib.request.Request(url, headers=_headers(token))
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as res:
+            return json.load(res), dict(res.headers)
+    except urllib.error.HTTPError as e:
+        try:
+            body = e.read().decode("utf-8", "replace")[:500]
+        except Exception:
+            body = ""
+        if e.code == 404:
+            raise RuntimeError(f"GitHub 404 for {url}: user/repo not found. {body}")
+        if e.code in (401, 403):
+            # 403 almost always means the anonymous rate limit, not bad auth.
+            # Worth spelling out because it bites everyone exactly once.
+            reset = e.headers.get("x-ratelimit-reset", "")
+            msg = f"GitHub {e.code} for {url}."
+            if "rate limit" in body.lower() or e.code == 403:
+                msg += " Rate limited — pass --token or set GH_TOKEN to raise limit from 60/hr."
+                if reset:
+                    msg += f" Resets at epoch {reset}."
+            else:
+                msg += f" Check token. {body}"
+            raise RuntimeError(msg)
+        raise RuntimeError(f"GitHub {e.code} for {url}: {body}")
+
+
+def normalize(r):
+    # Trim the API payload down to what the rest of the tool actually touches.
+    full = r.get("full_name", "")
+    branch = r.get("default_branch") or ""
+    return {
+        "full_name": full,
+        "html_url": r.get("html_url", ""),
+        "clone_url": r.get("clone_url", ""),
+        "ssh_url": r.get("ssh_url", ""),
+        "tarball_url": f"{API}/repos/{full}/tarball/{branch}" if full else "",
+        "default_branch": branch,
+        "description": r.get("description") or "",
+        "language": r.get("language") or "",
+        "topics": r.get("topics") or [],
+        "stars": r.get("stargazers_count", 0),
+        "fork": bool(r.get("fork", False)),
+        "archived": bool(r.get("archived", False)),
+        "pushed_at": r.get("pushed_at") or "",
+    }
+
+
+def get_authenticated_user(token, timeout=20):
+    data, _ = _get_json(f"{API}/user", token, timeout)
+    login = data.get("login", "")
+    if not login:
+        raise RuntimeError("Could not resolve authenticated user from token.")
+    return login
+
+
+def fetch_starred(user, token=None, per_page=100, limit=0, timeout=20):
+    # Walk pages until a short page arrives. limit=0 means "all of them".
+    out = []
+    page = 1
+    per_page = max(1, min(100, per_page))
+    while True:
+        url = f"{API}/users/{user}/starred?per_page={per_page}&page={page}"
+        data, _ = _get_json(url, token, timeout)
+        if not isinstance(data, list):
+            raise RuntimeError(f"Unexpected response for {url}: {str(data)[:200]}")
+        out.extend(normalize(r) for r in data)
+        if limit and len(out) >= limit:
+            return out[:limit]
+        if len(data) < per_page or page >= 100:
+            break
+        page += 1
+    return out
+
+
+def filter_repos(repos, language=None, topic=None, query=None,
+                 include_forks=True, include_archived=True):
+    lang = language.lower() if language else None
+    top = topic.lower() if topic else None
+    q = query.lower() if query else None
+
+    def keep(r):
+        if not include_forks and r.get("fork"):
+            return False
+        if not include_archived and r.get("archived"):
+            return False
+        if lang and (r.get("language") or "").lower() != lang:
+            return False
+        if top and top not in [t.lower() for t in r.get("topics", [])]:
+            return False
+        if q and q not in r.get("full_name", "").lower() \
+                and q not in (r.get("description") or "").lower():
+            return False
+        return True
+
+    return [r for r in repos if keep(r)]

stardown-0.3.0/stardown/async_download.py

@@ -0,0 +1,216 @@
+"""The fast path: stream repo tarballs concurrently, fall back to git.
+
+Why it's shaped like this:
+- one shared AsyncClient so connections get reused instead of re-handshaked
+- a semaphore around everything so we can't run the FD table dry
+- big read chunks, because syscalls aren't free
+- .part files + atomic rename, so a killed run never leaves a half file
+  wearing a finished file's name
+- tar extraction in a thread — tarfile would stall the loop otherwise
+- uvloop when it's around (Linux), plain asyncio everywhere else
+"""
+
+import asyncio
+import os
+import tarfile
+import time
+from pathlib import Path
+
+import httpx
+
+CHUNK = 128 * 1024
+RETRIES = 3
+
+
+def _maybe_uvloop():
+    try:
+        import uvloop
+        asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
+    except ImportError:
+        pass
+
+
+def _paths(repo, out_dir):
+    dest = Path(out_dir) / repo["full_name"]
+    archive = dest.parent / (dest.name + ".tar.gz")
+    part = archive.with_suffix(".tar.gz.part")
+    done = dest / ".stardown-done"
+    return dest, archive, part, done
+
+
+def _extract_strip_top(archive, dest):
+    # GitHub wraps every tarball in one top-level dir (owner-repo-sha).
+    # Nobody wants that dir, so peel it off on the way in. Blocking — the
+    # caller runs this in a thread.
+    dest.mkdir(parents=True, exist_ok=True)
+    with tarfile.open(archive, "r:gz") as tf:
+        members = tf.getmembers()
+        prefix = os.path.commonprefix([m.name for m in members if m.name])
+        if "/" in prefix:
+            # commonprefix works on characters, not path segments — back up
+            # to the last slash or we'd mangle sibling names.
+            prefix = prefix.rsplit("/", 1)[0] + "/"
+        else:
+            prefix = ""
+        for m in members:
+            name = m.name
+            if prefix and name.startswith(prefix):
+                name = name[len(prefix):]
+            if not name or name in ("/", "."):
+                continue
+            m.name = name
+            tf.extract(m, dest, filter="data")
+
+
+async def _git(args, timeout):
+    p = await asyncio.create_subprocess_exec(
+        "git", *args,
+        stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE,
+    )
+    try:
+        out, err = await asyncio.wait_for(p.communicate(), timeout)
+    except asyncio.TimeoutError:
+        p.kill()
+        raise RuntimeError("git timed out")
+    if p.returncode != 0:
+        raise RuntimeError((err or out).decode("utf-8", "replace").strip()[-300:])
+
+
+async def _git_one(repo, out_dir, sem, use_ssh, shallow, timeout):
+    dest = Path(out_dir) / repo["full_name"]
+    async with sem:
+        if (dest / ".git").is_dir():
+            await _git(["-C", str(dest), "pull", "--ff-only", "--quiet"], timeout)
+            return "updated"
+        url = repo["ssh_url"] if use_ssh else repo["clone_url"]
+        if not url:
+            raise RuntimeError("no clone URL")
+        dest.parent.mkdir(parents=True, exist_ok=True)
+        args = ["clone", "--quiet"]
+        if shallow:
+            args += ["--depth", "1"]
+        await _git([*args, url, str(dest)], timeout)
+        return "cloned"
+
+
+async def _tar_one(client, repo, out_dir, sem, progress, overall,
+                   keep_tar, extract, force, retries):
+    name = repo["full_name"]
+    dest, archive, part, done = _paths(repo, out_dir)
+    if done.exists() and not force and dest.is_dir():
+        if progress is not None and overall is not None:
+            progress.advance(overall)
+        return "cached"
+    url = repo.get("tarball_url") or (
+        f"https://api.github.com/repos/{name}/tarball")
+    last_err = "unknown"
+    async with sem:
+        for attempt in range(1, retries + 1):
+            task = None
+            try:
+                dest.parent.mkdir(parents=True, exist_ok=True)
+                resume_from = part.stat().st_size if part.exists() else 0
+                headers = {}
+                if resume_from:
+                    headers["Range"] = f"bytes={resume_from}-"
+                async with client.stream("GET", url, headers=headers) as resp:
+                    if resp.status_code == 404:
+                        raise RuntimeError("repo/tarball not found (private? need --token)")
+                    if resp.status_code in (403, 429):
+                        retry_after = resp.headers.get("retry-after")
+                        wait = int(retry_after) if str(retry_after or "").isdigit() else 2 ** attempt
+                        raise RuntimeError(f"rate limited, retry in {wait}s")
+                    if resp.status_code not in (200, 206):
+                        raise RuntimeError(f"HTTP {resp.status_code}")
+                    if resp.status_code == 200 and resume_from:
+                        resume_from = 0  # server shrugged at Range; start over
+                    total = int(resp.headers.get("content-length") or 0)
+                    if resp.status_code == 206:
+                        total += resume_from
+                    if progress is not None:
+                        task = progress.add_task("dl", name=name,
+                                                 total=total or None,
+                                                 completed=resume_from)
+                    mode = "ab" if resume_from else "wb"
+                    loop = asyncio.get_running_loop()
+                    with open(part, mode) as f:
+                        async for chunk in resp.aiter_bytes(CHUNK):
+                            if not chunk:
+                                continue
+                            # Synchronous write inside an async loop looks
+                            # wrong until you remember the network is ~1000x
+                            # slower than the disk. It never shows up.
+                            f.write(chunk)
+                            if progress is not None and task is not None:
+                                progress.update(task, advance=len(chunk))
+                os.replace(part, archive)
+                if extract:
+                    await loop.run_in_executor(None, _extract_strip_top, archive, dest)
+                    if not keep_tar:
+                        archive.unlink(missing_ok=True)
+                    done.write_text(f"{name} {time.time():.0f}\n")
+                if progress is not None:
+                    if task is not None:
+                        progress.update(task, visible=False)
+                    if overall is not None:
+                        progress.advance(overall)
+                return "resumed" if resume_from else "downloaded"
+            except Exception as e:
+                last_err = str(e)[:200]
+                if progress is not None and task is not None:
+                    progress.update(task, visible=False)
+                if attempt < retries:
+                    await asyncio.sleep(2 ** attempt)
+        if progress is not None and overall is not None:
+            progress.advance(overall)
+        raise RuntimeError(last_err)
+
+
+async def _amain(repos, out_dir, workers, method, token, progress,
+                 use_ssh, shallow, git_timeout, keep_tar, extract, force):
+    _maybe_uvloop()
+    sem = asyncio.Semaphore(max(1, min(64, workers)))
+    headers = {"User-Agent": "StarDown/0.3.0",
+               "Accept": "application/vnd.github+json"}
+    if token:
+        headers["Authorization"] = f"Bearer {token}"
+    limits = httpx.Limits(max_connections=max(1, workers),
+                          max_keepalive_connections=max(1, workers))
+    timeout = httpx.Timeout(connect=10.0, read=60.0, write=10.0, pool=10.0)
+    overall = progress.add_task("all", name="total",
+                                total=len(repos)) if progress is not None else None
+    results = []
+
+    if method == "git":
+        async def one_git(r):
+            try:
+                s = await _git_one(r, out_dir, sem, use_ssh, shallow, git_timeout)
+                results.append((r["full_name"], s, ""))
+            except Exception as e:
+                results.append((r["full_name"], "failed", str(e)[:300]))
+            finally:
+                if progress is not None and overall is not None:
+                    progress.advance(overall)
+        await asyncio.gather(*(one_git(r) for r in repos))
+        return results
+
+    async with httpx.AsyncClient(headers=headers, limits=limits,
+                                 timeout=timeout, follow_redirects=True) as client:
+        async def one_tar(r):
+            try:
+                s = await _tar_one(client, r, out_dir, sem, progress, overall,
+                                   keep_tar, extract, force, RETRIES)
+                results.append((r["full_name"], s, ""))
+            except Exception as e:
+                results.append((r["full_name"], "failed", str(e)[:300]))
+        await asyncio.gather(*(one_tar(r) for r in repos))
+    return results
+
+
+def download_repos(repos, out_dir, workers=16, method="tar", token=None,
+                   progress=None, use_ssh=False, shallow=True, git_timeout=300,
+                   keep_tar=False, extract=True, force=False):
+    # The CLI is sync; this is the one place asyncio gets entered.
+    return asyncio.run(_amain(repos, out_dir, workers, method, token, progress,
+                              use_ssh, shallow, git_timeout,
+                              keep_tar, extract, force))