| """D4's raw inputs, fetched on a Colab VM and pushed to the public hub repo as they land. |
| |
| Four stages, each skipped when its output is already on the hub (so a recycled VM resumes): |
| |
| sic SEC's bulk submissions.zip -> raw/cik_sic.jsonl: every CIK's name and current SIC code |
| cpc the CPC title list -> raw/cpc_titles.json: section / class / subclass titles |
| hupd HUPD's Jan-2016 sample and 2018 year -> raw/patents/<part>.jsonl: title, abstract, |
| claims and CPC labels per application |
| edgar EDGAR-CORPUS's validate + test files, 1993-2020 -> raw/10k/<year>_<split>.jsonl: |
| Item 1 (Business) of each 10-K whose filer has a usable SIC code |
| edgar_train the train files of D4_TRAIN_YEARS, for the companies the validate + test files |
| don't have -> raw/10k/<year>_train.jsonl |
| |
| python fetch_d4.py [stage ...] (default: all five, in that order) |
| |
| SEC's fair-access policy: one request (submissions.zip), sent with Chris's contact as the |
| User-Agent. Everything else comes from the HF hub or the CPC site. |
| """ |
| import io |
| import json |
| import os |
| import re |
| import sys |
| import tarfile |
| import time |
| import zipfile |
| from pathlib import Path |
|
|
| import requests |
| from huggingface_hub import HfApi, hf_hub_download, hf_hub_url |
|
|
| REPO = "ChrisMcCormick/encoder-rtx-d4-records" |
| WORK = Path(os.environ.get("D4_WORK", "/content/d4")) |
| SEC_UA = "Chris McCormick chris.mccormick@nearist.ai" |
| EDGAR_REPO, EDGAR_REV = "eloukas/edgar-corpus", "7e90f0f342569b35213445f809cfaf3b91f9964f" |
| HUPD_REPO, HUPD_REV = "HUPD/hupd", "f570a84b03663180b6034c1f7f4c15864f94385e" |
| COOKBOOK_REPO, COOKBOOK_REV = "ChrisMcCormick/encoder-rtx-cookbook-dev", "406c2af0245737cd29c83f0d941be63156ba5990" |
| CPC_URL = "https://www.cooperativepatentclassification.org/sites/default/files/cpc/bulk/CPCTitleList202608.zip" |
|
|
| api = HfApi() |
| api.create_repo(REPO, repo_type="dataset", private=False, exist_ok=True) |
| on_hub = set(api.list_repo_files(REPO, repo_type="dataset")) |
| WORK.mkdir(parents=True, exist_ok=True) |
|
|
|
|
| def log(*a): |
| print(time.strftime("%H:%M:%S"), *a, flush=True) |
|
|
|
|
| def push(local: Path, path_in_repo: str, msg: str): |
| for attempt in range(5): |
| try: |
| api.upload_file(path_or_fileobj=str(local), path_in_repo=path_in_repo, repo_id=REPO, |
| repo_type="dataset", commit_message=msg) |
| log(f"pushed {path_in_repo} ({local.stat().st_size / 1e6:.1f} MB)") |
| return |
| except Exception as e: |
| log(f"push {path_in_repo} failed ({e!r}); retry {attempt + 1}") |
| time.sleep(30 * (attempt + 1)) |
| raise RuntimeError(f"could not push {path_in_repo}") |
|
|
|
|
| def write_jsonl(path: Path, rows): |
| with path.open("w", encoding="utf-8") as f: |
| for r in rows: |
| f.write(json.dumps(r, ensure_ascii=False) + "\n") |
|
|
|
|
| |
| |
| |
|
|
| def stage_sic(): |
| out = WORK / "cik_sic.jsonl" |
| zpath = WORK / "submissions.zip" |
| if not zpath.exists(): |
| log("downloading submissions.zip from SEC") |
| with requests.get("https://www.sec.gov/Archives/edgar/daily-index/bulkdata/submissions.zip", |
| headers={"User-Agent": SEC_UA, "Accept-Encoding": "gzip, deflate"}, |
| stream=True, timeout=120) as r: |
| r.raise_for_status() |
| with open(zpath, "wb") as f: |
| for chunk in r.iter_content(1 << 22): |
| f.write(chunk) |
| log(f"submissions.zip {zpath.stat().st_size / 1e9:.2f} GB") |
| field = {k: re.compile(r'"%s":\s*("(?:[^"\\]|\\.)*")' % k) for k in ("cik", "sic", "sicDescription", "name", "entityType")} |
| rows, full_parses = [], 0 |
| with zipfile.ZipFile(zpath) as z: |
| names = [n for n in z.namelist() if n.startswith("CIK") and "-submissions-" not in n] |
| log(f"{len(names):,} CIK files") |
| for i, n in enumerate(names): |
| with z.open(n) as f: |
| head = f.read(8192).decode("utf-8", "replace") |
| got = {k: (json.loads(m.group(1)) if (m := rx.search(head)) else None) for k, rx in field.items()} |
| if got["cik"] is None or got["name"] is None: |
| full_parses += 1 |
| d = json.loads(z.read(n)) |
| got = {k: d.get(k) for k in field} |
| if got["sic"]: |
| rows.append(dict(cik=str(int(got["cik"])), name=got["name"], sic=got["sic"], |
| sic_description=got["sicDescription"], entity_type=got["entityType"])) |
| if i % 100000 == 0: |
| log(f" {i:,} files, {len(rows):,} with SIC") |
| write_jsonl(out, rows) |
| log(f"cik_sic: {len(rows):,} CIKs with a SIC code ({full_parses} needed a full parse)") |
| push(out, "raw/cik_sic.jsonl", f"raw/cik_sic.jsonl: {len(rows):,} CIKs with a SIC code (SEC submissions.zip)") |
|
|
|
|
| |
| |
| |
|
|
| def stage_cpc(): |
| out = WORK / "cpc_titles.json" |
| r = requests.get(CPC_URL, headers={"User-Agent": "Mozilla/5.0"}, timeout=120) |
| r.raise_for_status() |
| titles = {} |
| with zipfile.ZipFile(io.BytesIO(r.content)) as z: |
| for n in sorted(z.namelist()): |
| for line in z.read(n).decode("utf-8").splitlines(): |
| parts = line.split("\t") |
| if len(parts) >= 3 and parts[1] == "" and len(parts[0]) <= 4: |
| titles[parts[0]] = parts[2] |
| out.write_text(json.dumps(titles, indent=0, ensure_ascii=False), encoding="utf-8") |
| log(f"cpc titles: {len(titles):,} codes ({sum(len(k) == 4 for k in titles):,} subclasses)") |
| push(out, "raw/cpc_titles.json", f"raw/cpc_titles.json: {len(titles):,} CPC section/class/subclass titles ({CPC_URL.rsplit('/', 1)[1]})") |
|
|
|
|
| |
| |
| |
|
|
| def stage_hupd(): |
| for part in ("sample-jan-2016", "2018"): |
| target = f"raw/patents/{part}.jsonl" |
| if target in on_hub: |
| log(f"{target} on the hub; skipping") |
| continue |
| url = hf_hub_url(HUPD_REPO, f"data/{part}.tar.gz", repo_type="dataset", revision=HUPD_REV) |
| out = WORK / f"patents_{part}.jsonl" |
| n = 0 |
| with requests.get(url, stream=True, timeout=120) as r, out.open("w", encoding="utf-8") as f: |
| r.raise_for_status() |
| with tarfile.open(fileobj=r.raw, mode="r|gz") as tar: |
| for m in tar: |
| if not m.isfile() or not m.name.endswith(".json"): |
| continue |
| d = json.load(tar.extractfile(m)) |
| if n == 0: |
| log(f"{part}: keys {sorted(d)}") |
| f.write(json.dumps({k: d.get(k) for k in ( |
| "application_number", "publication_number", "title", "decision", "filing_date", |
| "main_cpc_label", "cpc_labels", "main_ipcr_label", "abstract", "claims")}, ensure_ascii=False) + "\n") |
| n += 1 |
| if n % 10000 == 0: |
| log(f" {part}: {n:,} applications") |
| log(f"{part}: {n:,} applications") |
| push(out, target, f"{target}: {n:,} HUPD applications (title, abstract, claims, CPC labels)") |
|
|
|
|
| |
| |
| |
|
|
| def stage_edgar(train_years=()): |
| """validate + test files of every year; with `train_years`, those years' train files, keeping |
| only companies the validate + test files didn't have (more companies, not more filings each).""" |
| sic_path = WORK / "cik_sic.jsonl" |
| if not sic_path.exists(): |
| sic_path = Path(hf_hub_download(REPO, "raw/cik_sic.jsonl", repo_type="dataset", local_dir=WORK / "hub")) |
| sic = {r["cik"]: r["sic"] for r in map(json.loads, sic_path.open(encoding="utf-8"))} |
| cookbook = Path(hf_hub_download(COOKBOOK_REPO, "data/cookbook_dev.jsonl", repo_type="dataset", revision=COOKBOOK_REV, |
| local_dir=WORK / "cookbook")) |
| held = {json.loads(l)["_meta"]["id"].split("/")[1].split("_")[0] for l in cookbook.open(encoding="utf-8") |
| if "classification_using_confidence" in l} |
| log(f"{len(sic):,} CIKs with SIC; {len(held)} Cookbook-dev filers kept out: {sorted(held)[:5]}...") |
| covered = set() |
| if train_years: |
| for p in sorted(api.list_repo_files(REPO, repo_type="dataset")): |
| if p.startswith("raw/10k/") and not p.endswith("_train.jsonl"): |
| local = Path(hf_hub_download(REPO, p, repo_type="dataset", local_dir=WORK / "hub")) |
| covered |= {json.loads(l)["cik"] for l in local.open(encoding="utf-8")} |
| log(f"train files {train_years}: keeping companies outside the {len(covered):,} the validate + test files cover") |
| files = [(y, s) for y in range(1993, 2021) for s in ("validate", "test")] + [(y, "train") for y in train_years] |
| for year, split in files: |
| target = f"raw/10k/{year}_{split}.jsonl" |
| if target in on_hub: |
| continue |
| url = hf_hub_url(EDGAR_REPO, f"{year}/{split}.jsonl", repo_type="dataset", revision=EDGAR_REV) |
| out = WORK / f"10k_{year}_{split}.jsonl" |
| for attempt in range(4): |
| try: |
| counts = dict(rows=0, kept=0, no_sic=0, cookbook=0, covered=0, short=0, long=0) |
| with requests.get(url, stream=True, timeout=120) as r, out.open("w", encoding="utf-8") as f: |
| r.raise_for_status() |
| for line in r.iter_lines(chunk_size=1 << 20): |
| if not line: |
| continue |
| d = json.loads(line) |
| counts["rows"] += 1 |
| cik = str(int(d["cik"])) |
| if cik in held: |
| counts["cookbook"] += 1 |
| continue |
| if cik not in sic: |
| counts["no_sic"] += 1 |
| continue |
| if split == "train" and cik in covered: |
| counts["covered"] += 1 |
| continue |
| text = re.sub(r"\s+", " ", d.get("section_1") or "").strip() |
| words = len(text.split()) |
| if words < 150: |
| counts["short"] += 1 |
| continue |
| if words > 40000: |
| counts["long"] += 1 |
| continue |
| f.write(json.dumps(dict(cik=cik, year=int(d["year"]), filename=d["filename"], words=words, |
| text=text), ensure_ascii=False) + "\n") |
| counts["kept"] += 1 |
| break |
| except (requests.RequestException, json.JSONDecodeError) as e: |
| log(f"{target}: {e!r}; retry {attempt + 1}") |
| time.sleep(20) |
| else: |
| raise RuntimeError(f"could not read {year}/{split}") |
| log(f"{target}: {counts}") |
| push(out, target, f"{target}: Item 1 of {counts['kept']:,} of {counts['rows']:,} 10-Ks ({counts})") |
| out.unlink() |
|
|
|
|
| |
| |
| |
| TRAIN_YEARS = tuple(int(y) for y in os.environ.get("D4_TRAIN_YEARS", "1996,1997,1998,1999,2000,2001,2003,2006,2009,2012,2015,2018").split(",")) |
| STAGES = dict(sic=stage_sic, cpc=stage_cpc, hupd=stage_hupd, edgar=stage_edgar, |
| edgar_train=lambda: stage_edgar(TRAIN_YEARS)) |
| OUTPUT = dict(sic="raw/cik_sic.jsonl", cpc="raw/cpc_titles.json") |
|
|
| if __name__ == "__main__": |
| for name in sys.argv[1:] or list(STAGES): |
| if OUTPUT.get(name) in on_hub: |
| log(f"{name}: {OUTPUT[name]} on the hub; skipping") |
| continue |
| log(f"== stage {name}") |
| STAGES[name]() |
| log("ALL DONE") |
|
|
