Download scripts/collect.py from Jl-wei/DesignSpecs: direct link, hf CLI and curl.
- Browser
- Download file 68.5 kB
-
https://huggingface.co/datasets/Jl-wei/DesignSpecs/resolve/refs%2Fpr%2F2/scripts/collect.py
- Command line
-
hf download hf://datasets/Jl-wei/DesignSpecs@refs/pr/2/scripts/collect.py
-
curl -L -o collect.py https://huggingface.co/datasets/Jl-wei/DesignSpecs/resolve/refs%2Fpr%2F2/scripts/collect.py
68.5 kB
#!/usr/bin/env python3
"""Collect public, non-fork DESIGN.md files using only Python's standard library.
Usage: python3 collect.py run --root RAW_ROOT --token-file TOKEN_FILE
python3 collect.py resume --root RAW_ROOT --token-file TOKEN_FILE
python3 collect.py status --root RAW_ROOT
python3 collect.py verify --root RAW_ROOT
Discovery finishes before downloading pinned snapshots. Original bytes and
metadata retain the version-2 layout consumed by filter.py. This standalone
script has no local helper-module dependencies.
"""
from __future__ import annotations
import argparse
import base64
import fcntl
import hashlib
import json
import logging
import math
import os
import re
import signal
import sqlite3
import sys
import tempfile
import time
import urllib.error
import urllib.parse
import urllib.request
from contextlib import closing
from datetime import datetime, timezone
from email.utils import parsedate_to_datetime
from http.client import IncompleteRead
from pathlib import Path
from urllib.parse import quote
LOG = logging.getLogger(__name__)
# GitHub requests and rate limits
class APIError(RuntimeError):
def __init__(self, status: int, path: str, message: str):
self.status = status
self.path = path
super().__init__(f"GitHub HTTP {status} for {path.split('?')[0]}: {message}")
def retry_after_seconds(value):
"""Interpret Retry-After as seconds or an HTTP date, ignoring bad values."""
if value is None:
return 0.0
try:
seconds = float(value)
return max(0.0, seconds) if math.isfinite(seconds) else 0.0
except (TypeError, ValueError):
try:
deadline = parsedate_to_datetime(str(value))
if deadline.tzinfo is None:
deadline = deadline.replace(tzinfo=timezone.utc)
return max(0.0, deadline.timestamp() - time.time())
except (TypeError, ValueError, OverflowError):
return 0.0
class SameHostRedirect(urllib.request.HTTPRedirectHandler):
def redirect_request(self, req, fp, code, msg, headers, newurl):
target = urllib.parse.urlparse(newurl)
if target.scheme != "https" or target.netloc != "api.github.com":
raise APIError(code, req.full_url, "refused cross-host redirect")
return super().redirect_request(req, fp, code, msg, headers, newurl)
class GitHubClient:
def __init__(self, token_file: Path):
token = token_file.read_text(encoding="utf-8").strip()
if not token or "\n" in token or "\r" in token:
raise ValueError("Token file must contain one nonempty token")
self._token = token
self._opener = urllib.request.build_opener(SameHostRedirect())
self._next = {"all": 0.0, "code": 0.0, "search": 0.0}
self._quota = {}
self.request_count = 0
@staticmethod
def bucket(path: str) -> str:
return "code" if path.startswith("/search/code") else "search" if path.startswith("/search/") else "core"
def _wait(self, path: str):
bucket = self.bucket(path)
now = time.time()
due = max(self._next["all"], self._next.get(bucket, 0))
# GitHub may report code search under either search or code_search.
for resource in (("code_search", "search") if bucket == "code" else ("search",) if bucket == "search" else ("core",)):
remaining, reset = self._quota.get(resource, (1, 0))
if remaining <= 0 and reset > now:
due = max(due, reset + 2)
while due > time.time():
delay = min(due - time.time(), 30)
if delay > 5:
LOG.info("Waiting %.0fs for GitHub rate limit (%s)", due - time.time(), bucket)
time.sleep(max(0, delay))
now = time.time()
self._next["all"] = now + 1.05
if bucket == "code":
self._next["code"] = now + 7.6
elif bucket == "search":
self._next["search"] = now + 2.6
def _remember_headers(self, headers):
try:
resource = headers.get("X-RateLimit-Resource")
if resource:
self._quota[resource] = (int(headers["X-RateLimit-Remaining"]), float(headers["X-RateLimit-Reset"]))
except (TypeError, ValueError, KeyError):
pass
def _request(self, path: str, params=None) -> bytes:
if not path.startswith("/") or path.startswith("//"):
raise ValueError("API paths must be relative to api.github.com")
url = "https://api.github.com" + path
if params:
url += ("&" if "?" in url else "?") + urllib.parse.urlencode(params)
headers = {"Authorization": "Bearer " + self._token, "Accept": "application/vnd.github+json",
"User-Agent": "design-md-corpus-collector/1.0", "X-GitHub-Api-Version": "2026-03-10"}
for attempt in range(6):
self._wait(path)
self.request_count += 1
try:
request = urllib.request.Request(url, headers=headers)
with self._opener.open(request, timeout=60) as response:
self._remember_headers(response.headers)
return response.read()
except urllib.error.HTTPError as exc:
self._remember_headers(exc.headers)
try:
message = str(json.loads(exc.read()).get("message", "request failed"))
except Exception:
message = "request failed"
finally:
exc.close()
# Never allow an upstream echo to disclose the credential.
message = message.replace(self._token, "[REDACTED]")[:400]
retryable = exc.code in (408, 429, 500, 502, 503, 504) or (exc.code == 403 and any(s in message.lower() for s in ("rate limit", "abuse", "secondary")))
if not retryable or attempt == 5:
raise APIError(exc.code, path, message) from None
delay = retry_after_seconds(exc.headers.get("Retry-After"))
delay = max(delay, min(60 * 2 ** attempt, 900) if exc.code in (403, 429) else min(2 ** attempt, 30))
LOG.warning("Retrying HTTP %s after %.0fs: %s", exc.code, delay, path.split("?")[0])
time.sleep(delay)
except (urllib.error.URLError, TimeoutError, OSError, IncompleteRead) as exc:
if attempt == 5:
raise APIError(0, path, type(exc).__name__) from None
time.sleep(min(2 ** attempt, 30))
raise AssertionError("unreachable")
def get_json(self, path: str, params=None):
return json.loads(self._request(path, params))
# Resumable search and coverage gaps
# REST code search excludes forks by default unless fork:true or fork:only
# is requested. Repository metadata is checked independently before download.
CODE_QUERY = "filename:design.md"
CODE_MAX_BYTES = 393216
PER_PAGE = 100
SEARCH_LIMIT = 1000
INCOMPLETE_ATTEMPTS = 3
REPOSITORY_TERMS = (
'"stitch.withgoogle.com/docs/design-md"',
'"google-labs-code/design.md"',
'"DESIGN.md" "stitch"',
)
REPOSITORY_START = int(datetime(2008, 1, 1, tzinfo=timezone.utc).timestamp())
JOB_COLUMNS = (
"kind", "query", "page", "lo", "hi", "state", "total_count",
"incomplete", "error",
)
class Discovery:
"""Discover repositories and commit progress after every search page."""
def __init__(self, client, db: sqlite3.Connection):
self.client = client
self.db = db
self._write(self._initialize_schema)
def _write(self, operation):
"""Commit each search page and its discoveries in one transaction."""
with self.db:
self.db.execute("BEGIN IMMEDIATE")
return operation()
def _initialize_schema(self):
self.db.execute("""
CREATE TABLE IF NOT EXISTS discovery_jobs (
kind TEXT NOT NULL,
query TEXT NOT NULL,
page INTEGER NOT NULL DEFAULT 1,
lo INTEGER NOT NULL,
hi INTEGER NOT NULL,
state TEXT NOT NULL DEFAULT 'pending',
total_count INTEGER,
incomplete INTEGER NOT NULL DEFAULT 0,
error TEXT,
UNIQUE(kind, query)
)
""")
self.db.execute("""
CREATE TABLE IF NOT EXISTS discovered_repositories (
repo_id INTEGER PRIMARY KEY,
full_name TEXT NOT NULL,
discovery_sources TEXT NOT NULL,
is_fork INTEGER
)
""")
self.db.execute("""
CREATE TABLE IF NOT EXISTS discovered_files (
repo_id INTEGER NOT NULL,
path TEXT NOT NULL,
search_blob_sha TEXT NOT NULL,
discovery_sources TEXT NOT NULL,
first_seen_at TEXT NOT NULL,
last_seen_at TEXT NOT NULL,
revision INTEGER NOT NULL DEFAULT 1,
PRIMARY KEY (repo_id, path)
)
""")
self.db.execute("""
CREATE TABLE IF NOT EXISTS repository_code_scopes (
repo_id INTEGER NOT NULL,
full_name TEXT NOT NULL,
query_base TEXT NOT NULL,
PRIMARY KEY (repo_id, query_base)
)
""")
self.db.execute("""
CREATE TABLE IF NOT EXISTS discovery_settings (
key TEXT PRIMARY KEY, value TEXT NOT NULL
)
""")
def run_code_search(self) -> dict:
"""Search case-insensitive filename candidates, sharded by byte size."""
self._write(lambda: self._enqueue("code", self._code_query(0, CODE_MAX_BYTES),
0, CODE_MAX_BYTES))
return self._run("code")
def run_repository_search(self) -> dict:
"""Supplement code search with README searches and creation shards."""
def enqueue_roots():
self.db.execute(
"INSERT OR IGNORE INTO discovery_settings(key, value) VALUES (?, ?)",
("repository_cutoff_utc", str(int(datetime.now(timezone.utc).timestamp()))),
)
cutoff = int(self.db.execute(
"SELECT value FROM discovery_settings WHERE key = ?",
("repository_cutoff_utc",),
).fetchone()[0])
for term in REPOSITORY_TERMS:
for archived in ("false", "true"):
base = f"{term} in:readme is:public archived:{archived}"
self._enqueue("repository", self._repository_query(
base, REPOSITORY_START, cutoff), REPOSITORY_START, cutoff)
self._write(enqueue_roots)
return self._run("repository")
def run_repository_code_search(self, repo_id: int, full_name: str) -> dict:
"""Resume code search within one repository, without scanning its trees."""
safe_characters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_.-"
parts = full_name.split("/") if isinstance(full_name, str) else []
if (not isinstance(repo_id, int) or isinstance(repo_id, bool) or repo_id <= 0
or len(parts) != 2
or any(part in ("", ".", "..") or any(c not in safe_characters for c in part)
for part in parts)):
raise ValueError("Repository search requires a positive ID and safe owner/repository name")
base = f"{CODE_QUERY} repo:{full_name}"
def enqueue_scope():
self.db.execute("""
INSERT INTO repository_code_scopes(repo_id, full_name, query_base)
VALUES (?, ?, ?)
ON CONFLICT(repo_id, query_base) DO UPDATE SET full_name = excluded.full_name
""", (repo_id, full_name, base))
self._enqueue("repository_code", self._code_query(0, CODE_MAX_BYTES, base),
0, CODE_MAX_BYTES)
self._write(enqueue_scope)
return self._run("repository_code", query_base=base)
def summary(self, kind: str | None = None, query_base: str | None = None) -> dict:
"""Return compact status; exact unresolved queries remain in SQLite."""
where, args = (" WHERE kind = ?", (kind,)) if kind else ("", ())
if query_base is not None:
prefix = query_base + " size:"
where += (" AND " if where else " WHERE ") + "substr(query, 1, ?) = ?"
args += (len(prefix), prefix)
states = {row[0]: row[1] for row in self.db.execute(
"SELECT state, COUNT(*) FROM discovery_jobs" + where + " GROUP BY state", args
)}
result = {"states": states, "repositories": self.db.execute(
"SELECT COUNT(*) FROM discovered_repositories"
).fetchone()[0]}
if query_base is not None:
result.update(query_base=query_base,
has_pending=any(states.get(state, 0)
for state in ("pending", "running", "error")),
has_gaps=any(states.get(state, 0)
for state in ("incomplete", "error")))
return result
@staticmethod
def _code_query(lo: int, hi: int, base: str = CODE_QUERY) -> str:
return f"{base} size:{lo}..{hi}"
@staticmethod
def _timestamp(value: int) -> str:
return datetime.fromtimestamp(value, timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
@classmethod
def _repository_query(cls, base: str, lo: int, hi: int) -> str:
return f"{base} created:{cls._timestamp(lo)}..{cls._timestamp(hi)}"
def _enqueue(self, kind: str, query: str, lo: int, hi: int) -> None:
self.db.execute("""
INSERT OR IGNORE INTO discovery_jobs(kind, query, lo, hi)
VALUES (?, ?, ?, ?)
""", (kind, query, lo, hi))
def _run(self, kind: str, query_base: str | None = None) -> dict:
# An exception leaves an error checkpoint; retry it on an explicit resume.
# Scoped searches must not replay another repository's failed queries.
# Match the literal base plus size separator; LIKE would treat valid
# repository underscores as wildcards and a raw prefix could match a
# different repository whose name starts with the requested name.
condition = "kind = ?"
args: tuple = (kind,)
if query_base is not None:
prefix = query_base + " size:"
condition += " AND substr(query, 1, ?) = ?"
args += (len(prefix), prefix)
self._write(lambda: self.db.execute("""
UPDATE discovery_jobs SET state = 'pending', error = NULL
WHERE """ + condition + " AND state IN ('running', 'error')", args))
while True:
row = self.db.execute(
"SELECT " + ", ".join(JOB_COLUMNS) +
" FROM discovery_jobs WHERE " + condition + " AND state = 'pending' ORDER BY rowid LIMIT 1",
args,
).fetchone()
if row is None:
break
job = dict(zip(JOB_COLUMNS, row))
self._page(job)
return self.summary(kind, query_base=query_base)
@staticmethod
def _empty_incomplete(result: dict) -> bool:
# Inspect the current raw response, not an earlier page's retained total.
# Zero hits with an incomplete flag is a timeout, not evidence that
# narrowing the range will recover hits. Splitting it grows an empty tree.
return (bool(result.get("incomplete_results"))
and int(result.get("total_count", 0)) == 0
and not result["items"])
def _response(self, job: dict) -> dict:
path = "/search/code" if job["kind"] in ("code", "repository_code") else "/search/repositories"
params = {"q": job["query"], "per_page": PER_PAGE, "page": job["page"]}
# Positive/saturated ranges can be narrowed; all-empty timeout responses
# must stop after bounded retries rather than create an exponential tree.
# Every call uses the existing client's limiter/backoff. Keep earlier
# retry hits separately so final-page pagination still uses the raw page.
prior_items = []
prior_total_count = 0
try:
for attempt in range(INCOMPLETE_ATTEMPTS):
result = self.client.get_json(path, params=params)
if not isinstance(result, dict) or not isinstance(result.get("items"), list):
raise ValueError("GitHub search returned an invalid response shape")
if (not result.get("incomplete_results")
or int(result.get("total_count", 0)) > SEARCH_LIMIT
or (job["lo"] < job["hi"] and not self._empty_incomplete(result))
or attempt + 1 == INCOMPLETE_ATTEMPTS):
return dict(result, _prior_items=prior_items,
_prior_total_count=prior_total_count)
prior_items.extend(result["items"])
prior_total_count = max(prior_total_count, int(result.get("total_count", 0)))
except Exception as exc:
self._write(lambda: self.db.execute("""
UPDATE discovery_jobs SET state = 'error', error = ?
WHERE kind = ? AND query = ?
""", (f"{type(exc).__name__}: {exc}"[:2000], job["kind"], job["query"])))
raise
def _page(self, job: dict) -> None:
result = self._response(job)
self._write(lambda: self._save_page(job, result))
def _save_page(self, job: dict, result: dict) -> None:
# A later retry may report fewer results after an incomplete response.
# Retain the largest observed total so a short final page cannot silently
# erase a coverage gap; a sufficiently complete retry can still recover.
total = max(int(result.get("total_count", 0)),
int(result.get("_prior_total_count", 0)), job["total_count"] or 0)
incomplete = bool(result.get("incomplete_results")) or bool(job["incomplete"])
saturated = total > SEARCH_LIMIT
items = result["items"]
for item in result.get("_prior_items", []) + items:
if not isinstance(item, dict):
continue
code_search = job["kind"] in ("code", "repository_code")
if code_search and not self._is_design_path(item.get("path")):
# Legacy filename search also returns substring/token
# matches. They must not seed expensive repository work.
continue
repo = item.get("repository", {}) if code_search else item
source = f"{job['kind']}:{job['query']}"
self._remember_repository(repo, source)
if code_search:
self._remember_file(repo, item, source)
if self._empty_incomplete(result):
state = "incomplete"
error = "empty_incomplete_results_after_3_attempts"
elif (saturated or incomplete) and job["lo"] < job["hi"]:
mid = (job["lo"] + job["hi"]) // 2
for lo, hi in ((job["lo"], mid), (mid + 1, job["hi"])):
if job["kind"] in ("code", "repository_code"):
base = job["query"].rsplit(" size:", 1)[0]
query = self._code_query(lo, hi, base)
else:
base = job["query"].rsplit(" created:", 1)[0]
query = self._repository_query(base, lo, hi)
self._enqueue(job["kind"], query, lo, hi)
state = "split"
error = "result_limit" if saturated else "incomplete_results"
else:
max_pages = max(1, math.ceil(min(total, SEARCH_LIMIT) / PER_PAGE))
expected = min(PER_PAGE, max(0, min(total, SEARCH_LIMIT) - (job["page"] - 1) * PER_PAGE))
short_page = len(items) < expected
incomplete = incomplete or saturated or short_page
if job["page"] < max_pages:
state = "pending"
else:
state = "incomplete" if incomplete else "complete"
error = job["error"]
if saturated:
error = "unsplittable_result_limit"
elif result.get("incomplete_results"):
error = "unsplittable_incomplete_results_after_3_attempts"
elif short_page:
error = "fewer_items_than_reported_total"
self.db.execute("""
UPDATE discovery_jobs
SET page = ?, state = ?, total_count = ?, incomplete = ?, error = ?
WHERE kind = ? AND query = ?
""", (job["page"] + 1, state, total, int(incomplete or saturated),
error, job["kind"], job["query"]))
def _remember_repository(self, repo: dict, source: str) -> None:
# Public must be explicit: a token may also expose private repositories.
if not isinstance(repo, dict) or repo.get("private") is not False:
return
repo_id, full_name = repo.get("id"), repo.get("full_name")
if not isinstance(repo_id, int) or not isinstance(full_name, str) or full_name.count("/") != 1:
return
if repo.get("fork") is True:
# Refresh a previously discovered repository's eligibility.
self.db.execute(
"UPDATE discovered_repositories SET is_fork = 1 WHERE repo_id = ?",
(repo_id,),
)
return
is_fork = 0 if repo.get("fork") is False else None
row = self.db.execute(
"SELECT discovery_sources FROM discovered_repositories WHERE repo_id = ?", (repo_id,)
).fetchone()
sources = json.loads(row[0]) if row else []
if source not in sources:
sources.append(source)
self.db.execute("""
INSERT INTO discovered_repositories(repo_id, full_name, discovery_sources, is_fork)
VALUES (?, ?, ?, ?)
ON CONFLICT(repo_id) DO UPDATE SET
full_name = excluded.full_name,
discovery_sources = excluded.discovery_sources,
is_fork = COALESCE(excluded.is_fork, discovered_repositories.is_fork)
""", (repo_id, full_name, json.dumps(sources, ensure_ascii=False), is_fork))
@staticmethod
def _is_design_path(path) -> bool:
"""Accept only safe Git-relative paths with the exact target basename."""
if not isinstance(path, str) or not path or "\x00" in path:
return False
parts = path.split("/")
return (all(part not in ("", ".", "..") for part in parts)
and parts[-1].casefold() == "design.md")
def _remember_file(self, repo: dict, item: dict, source: str) -> None:
"""Persist searchable file identity in the same transaction as its page."""
if (not isinstance(repo, dict) or repo.get("private") is not False
or repo.get("fork") is True):
return
repo_id = repo.get("id")
if not isinstance(repo_id, int) or isinstance(repo_id, bool):
return
known = self.db.execute(
"SELECT is_fork FROM discovered_repositories WHERE repo_id = ?", (repo_id,)
).fetchone()
if known is None or known[0] == 1:
return
path, sha = item.get("path"), item.get("sha")
if not self._is_design_path(path):
return
if (not isinstance(sha, str) or len(sha) not in (40, 64)
or any(c not in "0123456789abcdefABCDEF" for c in sha)):
return
sha = sha.lower()
row = self.db.execute("""
SELECT discovery_sources FROM discovered_files WHERE repo_id = ? AND path = ?
""", (repo_id, path)).fetchone()
sources = json.loads(row[0]) if row else []
if source not in sources:
sources.append(source)
observed_at = datetime.now(timezone.utc).isoformat()
self.db.execute("""
INSERT INTO discovered_files
(repo_id, path, search_blob_sha, discovery_sources, first_seen_at, last_seen_at)
VALUES (?, ?, ?, ?, ?, ?)
ON CONFLICT(repo_id, path) DO UPDATE SET
search_blob_sha = excluded.search_blob_sha,
discovery_sources = excluded.discovery_sources,
last_seen_at = excluded.last_seen_at,
revision = discovered_files.revision +
CASE WHEN discovered_files.search_blob_sha != excluded.search_blob_sha
THEN 1 ELSE 0 END
""", (repo_id, path, sha, json.dumps(sources, ensure_ascii=False), observed_at, observed_at))
# Pinned snapshots, original bytes and verification
FORMAT_VERSION = 2
def _now():
return datetime.now(timezone.utc).isoformat(timespec="seconds")
def _error(exc):
message = re.sub(r"(?:github_pat_|gh[pousr]_)[A-Za-z0-9_]+", "[REDACTED]", str(exc))
return {"type": type(exc).__name__, "message": message[:1000]}
def _safe_parts(value):
if not isinstance(value, str) or not value or "\x00" in value:
raise ValueError("Invalid empty or NUL-containing repository path")
parts = value.split("/")
if any(part in ("", ".", "..") for part in parts):
raise ValueError("Unsafe repository-relative path")
return parts
def _safe_full_name(full_name):
parts = _safe_parts(full_name)
if len(parts) != 2:
raise ValueError("Expected owner/repository name")
return parts
def _checked_path(base, parts, create_parents=False):
"""Reject symlinks below the configured base, including the final path."""
base = Path(base)
if base.is_symlink():
raise ValueError("Storage base must not be a symbolic link")
if create_parents:
base.mkdir(parents=True, exist_ok=True)
current = base
for index, part in enumerate(parts):
current = current / part
if current.is_symlink():
raise ValueError("Refusing symbolic link in storage path")
if create_parents and index < len(parts) - 1:
current.mkdir(exist_ok=True)
if index < len(parts) - 1 and current.exists() and not current.is_dir():
raise ValueError("Non-directory ancestor in storage path")
return current
def _atomic_bytes(path, content):
path = Path(path)
if path.is_symlink():
raise ValueError("Refusing to replace a symbolic link")
descriptor, temporary = tempfile.mkstemp(prefix=".designmd-", dir=path.parent)
try:
with os.fdopen(descriptor, "wb") as handle:
handle.write(content)
handle.flush()
os.fsync(handle.fileno())
os.replace(temporary, path)
finally:
if os.path.exists(temporary):
os.unlink(temporary)
def _json_bytes(value):
return (json.dumps(value, ensure_ascii=False, indent=2) + "\n").encode("utf-8")
def _write_json(path, value):
_atomic_bytes(path, _json_bytes(value))
def _read_json(path):
with Path(path).open("r", encoding="utf-8") as handle:
return json.load(handle)
def _git_blob_sha(content):
return hashlib.sha1(b"blob " + str(len(content)).encode("ascii") + b"\0" + content).hexdigest()
def _sha256(content):
return hashlib.sha256(content).hexdigest()
class SnapshotCollector:
"""Collect current default-branch snapshots with a stable resume boundary."""
def __init__(self, client, root: Path):
self.client = client
self.root = Path(root)
self.metadata_root = self.root / "_metadata"
self.data_root = self.root / "data"
def _metadata_file(self, storage_name, name):
return _checked_path(self.metadata_root, _safe_full_name(storage_name) + [name], True)
def _index_file(self, repo_id):
return _checked_path(self.metadata_root, ["_index", str(int(repo_id)) + ".json"], True)
def _read_records(self, storage_name):
path = self._metadata_file(storage_name, "files.jsonl")
records = {}
if path.exists():
with path.open("r", encoding="utf-8") as handle:
for line in handle:
if line.strip():
record = json.loads(line)
if record["path"] in records:
raise ValueError("Duplicate path in files.jsonl")
records[record["path"]] = record
return records
def _write_records(self, storage_name, records):
content = "".join(json.dumps(records[path], ensure_ascii=False, sort_keys=True) + "\n"
for path in sorted(records))
_atomic_bytes(self._metadata_file(storage_name, "files.jsonl"), content.encode("utf-8"))
def _save_snapshot(self, snapshot):
snapshot["updated_at"] = _now()
_write_json(self._metadata_file(snapshot["storage_full_name"], "snapshot.json"), snapshot)
def _checkpoint(self, snapshot, records):
"""Publish resolved identities before file records, on every exit path."""
if records is not None:
snapshot.update(self._counts(records))
self._save_snapshot(snapshot)
if records is not None:
self._write_records(snapshot["storage_full_name"], records)
def exclude_fork(self, repo_id):
"""Mark saved files as excluded history without moving or deleting them."""
index_path = self.metadata_root / "_index" / (str(int(repo_id)) + ".json")
if not index_path.exists():
return
index = _read_json(index_path)
if index.get("repo_id") != repo_id:
raise ValueError("Repository index identity mismatch")
path = _checked_path(self.metadata_root, _safe_full_name(index["storage_full_name"]) + ["snapshot.json"])
if path.exists():
snapshot = _read_json(path)
if snapshot.get("repo_id") != repo_id:
raise ValueError("Snapshot repository identity mismatch")
if snapshot.get("format_version") != FORMAT_VERSION:
raise ValueError("Older checkpoint format is unsupported; use a new collection root")
if snapshot["status"] == "excluded_fork":
return
snapshot.update(status="excluded_fork", fork=True, excluded_reason="fork_repository")
self._save_snapshot(snapshot)
def collect(self, repo_id: int, full_name: str, candidate_paths):
"""Fetch discovered paths at a pinned commit without scanning Git trees.
Candidates may be path strings or dictionaries containing path and
search_blob_sha. An empty list only rechecks previously saved paths.
Existing checkpoints are merged, not replaced, when new paths arrive.
"""
snapshot = None
records = None
try:
repo_id = int(repo_id)
_safe_full_name(full_name)
index_path = self._index_file(repo_id)
if index_path.exists():
index = _read_json(index_path)
if index.get("repo_id") != repo_id:
raise ValueError("Repository index identity mismatch")
storage_name = index["storage_full_name"]
snapshot_path = self._metadata_file(storage_name, "snapshot.json")
if snapshot_path.exists():
saved = _read_json(snapshot_path)
if saved.get("format_version") != FORMAT_VERSION:
raise ValueError("Older checkpoint format is unsupported; use a new collection root")
snapshot = saved
if snapshot.get("repo_id") != repo_id:
raise ValueError("Snapshot repository identity mismatch")
if snapshot["status"] == "excluded_fork":
return self._summary(snapshot)
records = self._read_records(storage_name)
repository = self.client.get_json(f"/repositories/{repo_id}")
if repository.get("id") != repo_id:
raise ValueError("GitHub returned a different repository identity")
canonical_name = repository["full_name"]
_safe_full_name(canonical_name)
public = repository.get("private") is False and repository.get("visibility", "public") == "public"
if public and repository.get("fork") is not False:
if repository.get("fork") is True:
self.exclude_fork(repo_id)
return {"status": "excluded_fork", "repo_id": repo_id, "full_name": canonical_name,
"files_saved": 0, "files_failed": 0, "candidates": 0, "excluded_reason": "fork_repository"}
raise ValueError("Repository metadata must explicitly report fork=false before downloading content")
if snapshot is None:
storage_name = index["storage_full_name"] if index_path.exists() else canonical_name
snapshot = {
"format_version": FORMAT_VERSION,
"repo_id": repo_id,
"storage_full_name": storage_name,
"canonical_full_name": canonical_name,
"full_name": canonical_name,
"requested_full_names": [full_name],
"observed_full_names": [canonical_name],
"created_at": _now(),
"status": "pending",
"history_collected": False,
"content_filter": "none",
"tree_complete": False,
"candidates": [],
}
self._save_snapshot(snapshot)
_write_json(index_path, {"repo_id": repo_id, "storage_full_name": storage_name})
records = self._read_records(storage_name)
else:
if full_name not in snapshot["requested_full_names"]:
snapshot["requested_full_names"].append(full_name)
if canonical_name not in snapshot["observed_full_names"]:
snapshot["observed_full_names"].append(canonical_name)
snapshot["canonical_full_name"] = canonical_name
snapshot["full_name"] = canonical_name
snapshot["repository_metadata_fetched_at"] = _now()
snapshot["public"] = public
if not snapshot["public"]:
# A token can grant more access than the corpus intends. Never
# fetch any Git objects from a non-public repository.
audit = {key: repository[key] for key in ("id", "full_name", "private", "visibility") if key in repository}
audit.update({"public": False, "excluded_reason": "non_public"})
_write_json(self._metadata_file(snapshot["storage_full_name"], "repository.json"), audit)
snapshot["excluded_reason"] = "non_public"
snapshot["status"] = "complete"
self._save_snapshot(snapshot)
summary = self._summary(snapshot)
summary.update({"public": False, "excluded_reason": "non_public"})
return summary
snapshot["fork"] = False
snapshot.pop("excluded_reason", None)
_write_json(self._metadata_file(snapshot["storage_full_name"], "repository.json"), repository)
endpoint = "/repos/" + "/".join(quote(part, safe="") for part in canonical_name.split("/"))
languages_path = self._metadata_file(snapshot["storage_full_name"], "languages.json")
if not languages_path.exists():
try:
languages = self.client.get_json(endpoint + "/languages")
_write_json(languages_path, languages)
snapshot["languages_fetched_at"] = _now()
snapshot.pop("languages_error", None)
except Exception as exc:
snapshot["languages_error"] = _error(exc)
if not snapshot.get("commit_sha"):
branch = repository.get("default_branch")
if not branch:
raise ValueError("Repository has no default branch")
reference = self.client.get_json(endpoint + "/git/ref/heads/" + quote(branch, safe=""))
snapshot["default_branch"] = branch
snapshot["commit_sha"] = reference["object"]["sha"]
snapshot["pinned_at"] = _now()
self._save_snapshot(snapshot)
if records is None:
records = self._read_records(snapshot["storage_full_name"])
snapshot["status"] = "partial"
snapshot.pop("completed_at", None)
snapshot["candidates"] = self._merge_direct_candidates(snapshot, candidate_paths)
snapshot["inventory_source"] = "code_search_paths"
snapshot["repository_inventory_complete"] = False
snapshot["tree_complete"] = False
self._save_snapshot(snapshot)
for entry in snapshot["candidates"]:
path = entry["path"]
previous = records.get(path)
try:
record = self._collect_direct_file(endpoint, snapshot, entry, previous)
except Exception as exc:
record = dict(previous or {})
record.update({"path": path, "status": "failed", "repo_id": repo_id,
"commit_sha": snapshot["commit_sha"], "blob_sha": entry.get("sha"),
"error": _error(exc), "attempted_at": _now()})
record["search_blob_shas"] = entry.get("search_blob_shas", [])
records[path] = record
self._checkpoint(snapshot, records)
expected_paths = {entry["path"] for entry in snapshot["candidates"]}
if set(records) - expected_paths:
raise ValueError("Metadata contains paths absent from the pinned snapshot")
counts = self._counts(records)
snapshot.update(counts)
final_status = "partial" if counts["files_failed"] or snapshot.get("languages_error") else "complete"
snapshot.pop("error", None)
# Publish completion only after both the candidate identities and
# final records are durable. A crash between those two writes can
# leave adopted bytes, but must never leave a false complete flag.
snapshot["status"] = "partial"
self._checkpoint(snapshot, records)
snapshot["status"] = final_status
if final_status == "complete":
snapshot["completed_at"] = _now()
self._save_snapshot(snapshot)
return self._summary(snapshot)
except (Exception, KeyboardInterrupt) as exc:
if snapshot is not None:
snapshot["status"] = "partial" if isinstance(exc, KeyboardInterrupt) else "failed"
snapshot["error"] = _error(exc)
try:
self._checkpoint(snapshot, records)
except Exception:
pass
if isinstance(exc, KeyboardInterrupt):
raise
return self._summary(snapshot)
if isinstance(exc, KeyboardInterrupt):
raise
return {"status": "failed", "repo_id": repo_id, "full_name": full_name,
"files_saved": 0, "files_failed": 0, "candidates": 0, "error": _error(exc)}
@staticmethod
def _merge_direct_candidates(snapshot, candidate_paths):
if not isinstance(candidate_paths, (list, tuple)):
raise TypeError("candidate_paths must be a list of paths or path dictionaries")
merged = {item["path"]: dict(item) for item in snapshot["candidates"]}
for value in candidate_paths:
item = {"path": value} if isinstance(value, str) else value
if not isinstance(item, dict) or not isinstance(item.get("path"), str):
raise ValueError("Each candidate must contain a string path")
path = item["path"]
if path.split("/")[-1].casefold() != "design.md":
continue
entry = merged.setdefault(path, {"path": path})
hashes = set(entry.get("search_blob_shas", []))
search_sha = item.get("search_blob_sha", item.get("sha"))
if search_sha is not None:
if not isinstance(search_sha, str):
raise ValueError("search_blob_sha must be a string")
hashes.add(search_sha)
entry["search_blob_shas"] = sorted(hashes)
return sorted(merged.values(), key=lambda item: item["path"])
def _collect_direct_file(self, endpoint, snapshot, entry, previous):
path = entry["path"]
parts = _safe_parts(path)
if parts[-1].casefold() != "design.md":
raise ValueError("Candidate basename must be design.md")
if previous and previous.get("commit_sha") != snapshot["commit_sha"]:
raise ValueError("File metadata belongs to a different snapshot")
target = _checked_path(self.data_root, _safe_full_name(snapshot["storage_full_name"]) + parts, True)
if previous and previous.get("status") == "excluded":
record = dict(previous)
record["search_blob_shas"] = entry.get("search_blob_shas", [])
return record
if entry.get("sha") and target.exists():
return self._collect_file(endpoint, snapshot, entry, previous)
contents_path = endpoint + "/contents/" + quote(path, safe="/")
try:
response = self.client.get_json(contents_path, {"ref": snapshot["commit_sha"]})
except Exception as exc:
if getattr(exc, "status", getattr(exc, "code", None)) != 404:
raise
entry["resolution"] = "missing_at_pinned_commit"
return self._direct_excluded(snapshot, entry, "missing_at_pinned_commit")
if isinstance(response, list):
entry["resolution"] = "not_file_at_pinned_commit"
return self._direct_excluded(snapshot, entry, "not_file_at_pinned_commit")
if not isinstance(response, dict) or response.get("path") != path:
raise ValueError("Contents API returned a different repository path")
if response.get("type") not in ("file", "symlink") or response.get("submodule_git_url"):
entry["resolution"] = "not_file_at_pinned_commit"
return self._direct_excluded(snapshot, entry, "not_file_at_pinned_commit")
sha = response.get("sha")
size = response.get("size")
if not isinstance(sha, str) or not re.fullmatch(r"[a-fA-F0-9]{40}", sha):
raise ValueError("Contents API returned an invalid Git blob SHA")
if not isinstance(size, int) or isinstance(size, bool) or size < 0:
raise ValueError("Contents API returned an invalid blob size")
entry.update({"sha": sha.lower(), "size": size, "type": "blob",
"mode": "120000" if response["type"] == "symlink" else None,
"contents_type": response["type"], "resolution": "resolved_at_pinned_commit",
"contents_api_url": "https://api.github.com" + contents_path + "?ref=" + snapshot["commit_sha"]})
# Contents API may follow an in-repository symlink and does not expose
# ordinary Git modes. Record that uncertainty; never create a symlink.
prefetched = response if response.get("encoding") == "base64" and response["type"] == "file" else None
return self._collect_file(endpoint, snapshot, entry, previous, prefetched_blob=prefetched)
@staticmethod
def _direct_excluded(snapshot, entry, reason):
return {"repo_id": snapshot["repo_id"], "full_name": snapshot["canonical_full_name"],
"storage_full_name": snapshot["storage_full_name"], "path": entry["path"],
"commit_sha": snapshot["commit_sha"], "status": "excluded", "reason": reason,
"checked_at": _now(), "search_blob_shas": entry.get("search_blob_shas", [])}
def _collect_file(self, endpoint, snapshot, entry, previous, prefetched_blob=None):
path = entry["path"]
base = {
"repo_id": snapshot["repo_id"],
"full_name": snapshot["canonical_full_name"],
"storage_full_name": snapshot["storage_full_name"],
"path": path,
"commit_sha": snapshot["commit_sha"],
"blob_sha": entry.get("sha"),
"git_mode": entry.get("mode"),
"git_type": entry.get("type"),
"is_symlink": entry.get("mode") == "120000" if entry.get("mode") is not None else None,
"expected_size": entry.get("size"),
"content_filter": "none",
}
base.update({"contents_type": entry["contents_type"], "contents_api_url": entry["contents_api_url"],
"git_mode_known": entry["mode"] is not None,
"search_blob_shas": entry.get("search_blob_shas", [])})
parts = _safe_parts(path)
target = _checked_path(self.data_root, _safe_full_name(snapshot["storage_full_name"]) + parts, True)
if previous and previous.get("commit_sha") != snapshot["commit_sha"]:
raise ValueError("File metadata belongs to a different snapshot")
if target.exists():
content = target.read_bytes()
if _git_blob_sha(content) != entry["sha"]:
raise ValueError("Existing file differs from the pinned Git blob; refusing overwrite")
if previous and previous.get("sha256") and _sha256(content) != previous["sha256"]:
raise ValueError("Existing file differs from its recorded SHA-256; refusing overwrite")
fetched_at = previous.get("fetched_at", _now()) if previous else _now()
adopted_existing = not previous
content_source = previous.get("content_source", "github_git_blob_api") if previous else "existing_verified_bytes"
source_api_url = previous.get("source_api_url") if previous else None
else:
response = prefetched_blob if prefetched_blob is not None else self.client.get_json(endpoint + "/git/blobs/" + entry["sha"])
if response.get("encoding") != "base64":
raise ValueError("GitHub blob endpoint did not return base64 content")
content = base64.b64decode(re.sub(r"\s+", "", response["content"]), validate=True)
if response.get("sha", entry["sha"]) != entry["sha"]:
raise ValueError("GitHub blob response SHA does not match requested object")
if response.get("size", len(content)) != len(content):
raise ValueError("GitHub blob response size mismatch")
if _git_blob_sha(content) != entry["sha"]:
raise ValueError("Downloaded bytes do not match the Git blob SHA")
if entry.get("size", len(content)) != len(content):
raise ValueError("Downloaded bytes do not match the recorded blob size")
content_source = "github_contents_api" if prefetched_blob is not None else "github_git_blob_api"
_atomic_bytes(target, content)
fetched_at = _now()
adopted_existing = False
source_api_url = entry["contents_api_url"] if prefetched_blob is not None else "https://api.github.com" + endpoint + "/git/blobs/" + entry["sha"]
if entry.get("size", len(content)) != len(content):
raise ValueError("Existing bytes do not match the recorded blob size")
relative_path = "/".join(_safe_full_name(snapshot["storage_full_name"]) + parts)
return dict(base, status="downloaded", size=len(content), sha256=_sha256(content),
data_path="data/" + relative_path, fetched_at=fetched_at, verified_at=_now(),
adopted_existing=adopted_existing,
content_source=content_source,
source_url="https://github.com/" + quote(snapshot["canonical_full_name"], safe="/")
+ "/blob/" + snapshot["commit_sha"] + "/" + quote(path, safe="/"),
source_api_url=source_api_url)
@staticmethod
def _counts(records):
return {
"files_saved": sum(item["status"] == "downloaded" for item in records.values()),
"files_failed": sum(item["status"] == "failed" for item in records.values()),
"files_excluded": sum(item["status"] == "excluded" for item in records.values()),
"bytes_saved": sum(item.get("size", 0) for item in records.values() if item["status"] == "downloaded"),
}
def _summary(self, snapshot):
summary = {key: snapshot[key] for key in ("status", "repo_id", "files_saved", "files_failed",
"files_excluded", "bytes_saved", "commit_sha", "public", "fork", "excluded_reason",
"error", "languages_error") if key in snapshot}
summary.setdefault("files_saved", 0)
summary.setdefault("files_failed", 0)
summary["full_name"] = snapshot["canonical_full_name"]
summary["candidates"] = len(snapshot["candidates"])
summary["metadata_directory"] = str(self.metadata_root / snapshot["storage_full_name"])
if snapshot["status"] == "excluded_fork":
summary.update(files_saved=0, files_failed=0, files_excluded=0, bytes_saved=0, candidates=0)
return summary
def verify(self):
"""Verify saved bytes and snapshot consistency without network requests."""
result = {"repositories": 0, "files": 0, "bytes": 0, "skipped_excluded_snapshots": 0, "problems": []}
if not self.metadata_root.exists():
result["ok"] = True
return result
for snapshot_path in sorted(self.metadata_root.glob("*/*/snapshot.json")):
try:
snapshot = _read_json(snapshot_path)
if snapshot.get("format_version") != FORMAT_VERSION:
raise ValueError("Older checkpoint format is unsupported; use a new collection root")
storage_name = snapshot["storage_full_name"]
expected_metadata = _checked_path(self.metadata_root, _safe_full_name(storage_name) + ["snapshot.json"])
if expected_metadata != snapshot_path:
raise ValueError("Snapshot location does not match its storage name")
if snapshot["status"] == "excluded_fork":
result["skipped_excluded_snapshots"] += 1
continue
result["repositories"] += 1
records = self._read_records(storage_name)
if snapshot["status"] != "complete":
result["problems"].append({"repository": storage_name, "reason": "snapshot_" + snapshot["status"]})
expected = {item["path"]: item for item in snapshot["candidates"]}
if set(expected) != set(records):
result["problems"].append({"repository": storage_name, "reason": "inventory_metadata_mismatch"})
for path, record in records.items():
if record["status"] != "downloaded":
continue
try:
target = _checked_path(self.data_root, _safe_full_name(storage_name) + _safe_parts(path))
content = target.read_bytes()
if record["commit_sha"] != snapshot["commit_sha"]:
raise ValueError("File snapshot commit mismatch")
if record["blob_sha"] != expected[path]["sha"]:
raise ValueError("File snapshot blob mismatch")
if len(content) != record["size"]:
raise ValueError("File size mismatch")
if _sha256(content) != record["sha256"]:
raise ValueError("File SHA-256 mismatch")
if _git_blob_sha(content) != record["blob_sha"]:
raise ValueError("File Git blob SHA mismatch")
result["files"] += 1
result["bytes"] += len(content)
except Exception as exc:
result["problems"].append({"repository": storage_name, "path": path, "error": _error(exc)})
except Exception as exc:
result["problems"].append({"snapshot": str(snapshot_path), "error": _error(exc)})
result["ok"] = not result["problems"]
return result
# Two-phase collection and checkpoints
def utc_now():
return datetime.now(timezone.utc).isoformat()
def atomic_json(path: Path, value):
path.parent.mkdir(parents=True, exist_ok=True)
_write_json(path, value)
def control_directory(root: Path):
return root / "_metadata" / "_collector"
def check_root(root: Path):
"""Reject incompatible collections before creating or modifying anything."""
database = control_directory(root) / "state.sqlite3"
if database.exists():
db = sqlite3.connect(database.resolve().as_uri() + "?mode=ro&immutable=1", uri=True)
try:
version = db.execute("PRAGMA user_version").fetchone()[0]
finally:
db.close()
if version != 2:
raise ValueError("Older checkpoint format is unsupported; use a new collection root")
manifest = control_directory(root) / "manifest.json"
if manifest.exists() and json.loads(manifest.read_text())["schema_version"] != 2:
raise ValueError("Older collection manifest is unsupported; use a new collection root")
elif root.exists() and any(root.iterdir()):
raise ValueError("Collection root must be empty or contain a current-format checkpoint")
def open_database(root: Path):
check_root(root)
control = control_directory(root)
control.mkdir(parents=True, exist_ok=True)
db = sqlite3.connect(control / "state.sqlite3")
db.execute("""CREATE TABLE IF NOT EXISTS collection_tasks (
repo_id INTEGER PRIMARY KEY, full_name TEXT NOT NULL,
state TEXT NOT NULL DEFAULT 'pending',
files_saved INTEGER NOT NULL DEFAULT 0, candidates INTEGER NOT NULL DEFAULT 0,
files_failed INTEGER NOT NULL DEFAULT 0, error TEXT, updated_at TEXT,
metadata_directory TEXT, processed_file_revision INTEGER NOT NULL DEFAULT 0)""")
db.execute("PRAGMA user_version=2")
db.commit()
# Store the format marker in the database header before enabling WAL.
# check_root can then inspect it without creating SQLite sidecar files.
db.execute("PRAGMA journal_mode=WAL")
db.execute("PRAGMA synchronous=FULL")
return db
class CollectorRunner:
def __init__(self, root: Path, client: GitHubClient, *, max_repositories=None):
self.root = root
self.client = client
self.max_repositories = max_repositories
self.processed = 0
self.phase = "initializing"
self.started_at = utc_now()
self.db = open_database(root)
self.discovery = Discovery(client, self.db)
self.snapshots = SnapshotCollector(client, root)
def add_repository(self, repo, source):
with self.db:
self.discovery._remember_repository(repo, source)
def _queue_discovered(self):
self.db.execute("""UPDATE discovered_repositories SET is_fork=1 WHERE repo_id IN
(SELECT repo_id FROM collection_tasks WHERE state IN ('excluded_fork','excluding_fork'))""")
self.db.execute("""INSERT OR IGNORE INTO collection_tasks(repo_id, full_name)
SELECT repo_id, full_name FROM discovered_repositories WHERE is_fork IS NULL OR is_fork=0""")
self.db.execute("""UPDATE collection_tasks SET state='pending',error=NULL
WHERE (state IN ('running','failed','partial') OR
COALESCE((SELECT SUM(revision) FROM discovered_files f
WHERE f.repo_id=collection_tasks.repo_id),0)>processed_file_revision)
AND state NOT IN ('excluded_fork','excluding_fork')
AND EXISTS (SELECT 1 FROM discovered_files f WHERE f.repo_id=collection_tasks.repo_id)
AND repo_id IN (SELECT repo_id FROM discovered_repositories WHERE is_fork IS NULL OR is_fork=0)""")
self.db.commit()
forks = self.db.execute("""SELECT repo_id FROM collection_tasks
WHERE state IN ('excluded_fork','excluding_fork') OR repo_id IN
(SELECT repo_id FROM discovered_repositories WHERE is_fork=1)""").fetchall()
for (repo_id,) in forks:
self.snapshots.exclude_fork(repo_id)
with self.db:
self.db.execute("""UPDATE collection_tasks SET state='excluded_fork',
files_saved=0,candidates=0,files_failed=0,error='fork_repository' WHERE repo_id=?""",
(repo_id,))
def discover(self):
"""Finish all discovery before downloading any repository files."""
self.phase = "discovery"
self.write_status("running")
seed = self.client.get_json("/repos/google-labs-code/design.md")
self.add_repository(seed, "official-seed")
self.discovery.run_code_search()
self.discovery.run_repository_search()
# Registered scopes may still have unfinished pages even if an earlier
# run already found files. Also search repositories with no indexed path.
scopes = set() if seed.get("fork") is True else {(seed["id"], seed["full_name"])}
scopes.update(self.db.execute("SELECT repo_id,full_name FROM repository_code_scopes"))
scopes.update(self.db.execute("""SELECT repo_id,full_name FROM discovered_repositories d
WHERE (is_fork IS NULL OR is_fork=0) AND NOT EXISTS
(SELECT 1 FROM discovered_files f WHERE f.repo_id=d.repo_id)"""))
for repo_id, full_name in sorted(scopes):
excluded = self.db.execute("""SELECT 1 FROM collection_tasks WHERE repo_id=?
AND state IN ('excluded_fork','excluding_fork') UNION SELECT 1
FROM discovered_repositories WHERE repo_id=? AND is_fork=1""", (repo_id,repo_id)).fetchone()
if excluded:
continue
try:
result = self.discovery.run_repository_code_search(repo_id, full_name)
state = "search_incomplete" if result["has_gaps"] else "no_indexed_files"
except Exception:
state = "search_incomplete"
LOG.exception("File path search failed for %s", full_name)
has_paths = self.db.execute("SELECT 1 FROM discovered_files WHERE repo_id=? LIMIT 1",
(repo_id,)).fetchone()
if not has_paths:
with self.db:
self.db.execute("""INSERT INTO collection_tasks(repo_id,full_name,state)
VALUES(?,?,?) ON CONFLICT(repo_id) DO UPDATE SET state=excluded.state""",
(repo_id, full_name, state))
self.write_status("running")
def process_pending(self):
"""Download queued snapshots; return whether a limit left work pending."""
self._queue_discovered()
while True:
row = self.db.execute("""SELECT repo_id, full_name FROM collection_tasks
WHERE state='pending' AND EXISTS
(SELECT 1 FROM discovered_files f WHERE f.repo_id=collection_tasks.repo_id)
ORDER BY repo_id LIMIT 1""").fetchone()
if not row:
return False
if self.max_repositories is not None and self.processed >= self.max_repositories:
return True
repo_id, full_name = row
entries = self.db.execute("""SELECT path,search_blob_sha,revision FROM discovered_files
WHERE repo_id=? ORDER BY path""", (repo_id,)).fetchall()
candidate_paths = [{"path": path, "search_blob_sha": sha} for path, sha, revision in entries]
inventory_revision = sum(entry[2] for entry in entries)
self.db.execute("UPDATE collection_tasks SET state='running',updated_at=? WHERE repo_id=?", (utc_now(), repo_id))
self.db.commit()
LOG.info("Snapshot %s", full_name)
try:
result = self.snapshots.collect(repo_id, full_name, candidate_paths=candidate_paths)
except Exception as exc:
result = {"status": "failed", "error": str(exc)}
LOG.exception("Snapshot failed for %s", full_name)
status = result.get("status", "failed")
if status == "excluded_fork":
self.db.execute("UPDATE discovered_repositories SET is_fork=1 WHERE repo_id=?", (repo_id,))
if status not in ("complete", "partial", "failed", "skipped", "excluded_fork"):
status = "failed"
self.db.execute("""UPDATE collection_tasks SET state=?, files_saved=?, candidates=?,
files_failed=?, error=?, updated_at=?, metadata_directory=?,processed_file_revision=? WHERE repo_id=?""",
(status, result.get("files_saved", 0), result.get("candidates", 0),
result.get("files_failed", 0), json.dumps(result.get("error") or result.get("languages_error"), ensure_ascii=False) if result.get("error") or result.get("languages_error") else None, utc_now(),
str(result.get("metadata_directory", "")), inventory_revision, repo_id))
self.db.commit()
self.processed += 1
LOG.info("Snapshot result %s: %s; files=%s failures=%s", full_name, status,
result.get("files_saved", 0), result.get("files_failed", 0))
self.write_status("running")
def write_status(self, state, error=None):
report = database_status(self.db)
report.update({"state": state, "phase": self.phase, "started_at": self.started_at,
"updated_at": utc_now(), "pid": os.getpid(), "requests_this_process": self.client.request_count,
"processed_this_process": self.processed, "error": error})
atomic_json(control_directory(self.root) / "status.json", report)
return report
def run(self):
control = control_directory(self.root)
with (control / "collector.lock").open("a+") as lock:
try:
fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB)
except BlockingIOError:
raise RuntimeError("A collector is already running for this destination") from None
manifest_path = control / "manifest.json"
if not manifest_path.exists():
atomic_json(manifest_path, {"schema_version": 2, "created_at": utc_now(),
"scope": "public non-fork repositories; pinned current default-branch snapshots",
"filename": "basename.casefold() == 'design.md'", "yaml_filter": False,
"history": False, "data_layout": "data/<owner>/<repo>/<original-path>",
"metadata_layout": "_metadata/<owner>/<repo>/", "fork_repository_policy": "exclude",
"collection_method": "code_search_paths_then_contents_at_pinned_commit",
"full_repository_tree_scan": False, "repository_inventory_complete": False,
"coverage_limits": ["GitHub search is not exhaustive",
"Only indexed default-branch paths are searched; no other branches or history",
"Saturated or incomplete leaf queries remain recorded as coverage gaps",
"Repository snapshots are taken at different times; each pins its own commit"]})
try:
self.discover()
self.phase = "snapshots"
limited = self.process_pending()
self.phase = "finished"
state = "batch_complete" if limited else "complete_with_gaps" if has_gaps(database_status(self.db)) else "complete"
return self.write_status(state)
except KeyboardInterrupt:
return self.write_status("interrupted")
except BaseException as exc:
self.write_status("failed", str(exc))
raise
def database_status(db):
tables = {row[0] for row in db.execute("SELECT name FROM sqlite_master WHERE type='table'")}
output = {}
for table, name in (("collection_tasks", "repositories"), ("discovery_jobs", "search_jobs")):
if table in tables:
output[name] = dict(db.execute(f"SELECT state,COUNT(*) FROM {table} GROUP BY state"))
if "collection_tasks" in tables:
saved, candidates, failures = db.execute("SELECT COALESCE(SUM(files_saved),0),COALESCE(SUM(candidates),0),COALESCE(SUM(files_failed),0) FROM collection_tasks").fetchone()
output.update(files_saved=saved, candidate_files=candidates, file_failures=failures)
if "discovered_repositories" in tables:
output["repositories_discovered"] = db.execute("SELECT COUNT(*) FROM discovered_repositories").fetchone()[0]
if "discovered_files" in tables:
output["file_paths_discovered"] = db.execute("SELECT COUNT(*) FROM discovered_files").fetchone()[0]
return output
def has_gaps(report):
return any(count for group in ("repositories", "search_jobs")
for state, count in report.get(group, {}).items() if state not in ("complete", "split", "superseded", "excluded_fork", "no_indexed_files"))
# Command-line interface
def main():
parser = argparse.ArgumentParser(description="Collect discovered DESIGN.md paths at pinned commits in public, non-fork repositories.")
parser.add_argument("command", choices=("run", "resume", "status", "verify"))
parser.add_argument("--root", type=Path, required=True,
help="Empty directory or version-2 collection; legacy checkpoint formats require a new root")
parser.add_argument("--token-file", type=Path, help="GitHub token file; required for run and resume")
parser.add_argument("--max-repositories", type=int, help="Limit repository downloads after discovery completes; remaining downloads can resume")
args = parser.parse_args()
logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s", stream=sys.stderr)
if args.command in ("run", "resume") and args.token_file is None:
parser.error("--token-file is required for " + args.command)
if args.max_repositories is not None and args.max_repositories < 1:
parser.error("--max-repositories must be positive")
if args.command == "status":
database = control_directory(args.root) / "state.sqlite3"
if not database.exists():
print(json.dumps({"state": "not_started"}))
return 0
with closing(sqlite3.connect(database.resolve().as_uri() + "?mode=ro", uri=True)) as db:
output = database_status(db)
status_path = control_directory(args.root) / "status.json"
if status_path.exists():
output["last_process_report"] = json.loads(status_path.read_text())
print(json.dumps(output, indent=2))
return 0
if args.command == "verify":
result = SnapshotCollector(None, args.root).verify()
print(json.dumps(result, indent=2))
return 1 if result.get("problems") else 0
check_root(args.root)
client = GitHubClient(args.token_file)
def interrupted(signum, frame):
raise KeyboardInterrupt()
signal.signal(signal.SIGTERM, interrupted)
signal.signal(signal.SIGINT, interrupted)
runner = CollectorRunner(args.root, client, max_repositories=args.max_repositories)
try:
report = runner.run()
finally:
runner.db.close()
print(json.dumps(report, indent=2))
return 1 if report.get("state") == "failed" else 0
if __name__ == "__main__":
raise SystemExit(main())
#!/usr/bin/env python3
"""Collect public, non-fork DESIGN.md files using only Python's standard library.
Usage: python3 collect.py run --root RAW_ROOT --token-file TOKEN_FILE
python3 collect.py resume --root RAW_ROOT --token-file TOKEN_FILE
python3 collect.py status --root RAW_ROOT
python3 collect.py verify --root RAW_ROOT
Discovery finishes before downloading pinned snapshots. Original bytes and
metadata retain the version-2 layout consumed by filter.py. This standalone
script has no local helper-module dependencies.
"""
from __future__ import annotations
import argparse
import base64
import fcntl
import hashlib
import json
import logging
import math
import os
import re
import signal
import sqlite3
import sys
import tempfile
import time
import urllib.error
import urllib.parse
import urllib.request
from contextlib import closing
from datetime import datetime, timezone
from email.utils import parsedate_to_datetime
from http.client import IncompleteRead
from pathlib import Path
from urllib.parse import quote
LOG = logging.getLogger(__name__)
# GitHub requests and rate limits
class APIError(RuntimeError):
def __init__(self, status: int, path: str, message: str):
self.status = status
self.path = path
super().__init__(f"GitHub HTTP {status} for {path.split('?')[0]}: {message}")
def retry_after_seconds(value):
"""Interpret Retry-After as seconds or an HTTP date, ignoring bad values."""
if value is None:
return 0.0
try:
seconds = float(value)
return max(0.0, seconds) if math.isfinite(seconds) else 0.0
except (TypeError, ValueError):
try:
deadline = parsedate_to_datetime(str(value))
if deadline.tzinfo is None:
deadline = deadline.replace(tzinfo=timezone.utc)
return max(0.0, deadline.timestamp() - time.time())
except (TypeError, ValueError, OverflowError):
return 0.0
class SameHostRedirect(urllib.request.HTTPRedirectHandler):
def redirect_request(self, req, fp, code, msg, headers, newurl):
target = urllib.parse.urlparse(newurl)
if target.scheme != "https" or target.netloc != "api.github.com":
raise APIError(code, req.full_url, "refused cross-host redirect")
return super().redirect_request(req, fp, code, msg, headers, newurl)
class GitHubClient:
def __init__(self, token_file: Path):
token = token_file.read_text(encoding="utf-8").strip()
if not token or "\n" in token or "\r" in token:
raise ValueError("Token file must contain one nonempty token")
self._token = token
self._opener = urllib.request.build_opener(SameHostRedirect())
self._next = {"all": 0.0, "code": 0.0, "search": 0.0}
self._quota = {}
self.request_count = 0
def bucket(path: str) -> str:
return "code" if path.startswith("/search/code") else "search" if path.startswith("/search/") else "core"
def _wait(self, path: str):
bucket = self.bucket(path)
now = time.time()
due = max(self._next["all"], self._next.get(bucket, 0))
# GitHub may report code search under either search or code_search.
for resource in (("code_search", "search") if bucket == "code" else ("search",) if bucket == "search" else ("core",)):
remaining, reset = self._quota.get(resource, (1, 0))
if remaining <= 0 and reset > now:
due = max(due, reset + 2)
while due > time.time():