Download ingest/webdata.py from amongglue/amber: direct link, hf CLI and curl.
- Browser
- Download file 9.14 kB
-
https://huggingface.co/datasets/amongglue/amber/resolve/main/ingest/webdata.py
- Command line
-
hf download hf://datasets/amongglue/amber/ingest/webdata.py
-
curl -L -o webdata.py https://huggingface.co/datasets/amongglue/amber/resolve/main/ingest/webdata.py
9.14 kB
| #!/usr/bin/env python3 | |
| """Shared machinery for ingesting EEG from general-purpose data repositories. | |
| Repositories like Zenodo and Dryad publish per-subject archives that are often | |
| several gigabytes each, so nothing is ever staged wholesale: one archive is | |
| fetched, unpacked, converted and deleted before the next is touched. The | |
| readable-signal detection and the give-up rule live here so every repository | |
| ingest behaves the same way. | |
| """ | |
| from __future__ import annotations | |
| import json, re, shutil, subprocess, sys, tarfile, time, zipfile | |
| from pathlib import Path | |
| ROOT = Path(__file__).resolve().parents[1] | |
| if str(ROOT) not in sys.path: | |
| sys.path.insert(0, str(ROOT)) | |
| OUT = ROOT / "data/eegx" | |
| # `.mat` is here because EEGLAB writes its `.set` structure as a MATLAB file | |
| # and archives routinely publish it under the .mat name instead -- whole | |
| # records were converting to nothing for that reason alone. Arbitrary .mat | |
| # files that are not EEGLAB structures simply fail to read and are skipped. | |
| SIGNAL_EXT = {".edf", ".bdf", ".rec", ".set", ".vhdr", ".fif", ".gdf", | |
| ".cnt", ".mff", ".nwb", ".eeg", ".data", ".mat"} | |
| # Archives holding stimuli, video, code or documents rather than recordings. | |
| # These dominate the byte count of some records -- one carries 36 GB of | |
| # narration audio -- and would burn the disk budget for zero hours. | |
| SKIP_NAME = re.compile( | |
| r"stimul|_audio|video|movie.?file|\bcode\b|script|figure|supplement" | |
| r"|readme|licen[cs]e|\.docx?$|\.pdf$|\.csv$|\.xlsx?$|\.wav$|\.mp[34]$" | |
| r"|\.avi$|\.mov$|\.png$|\.jpe?g$|\.tiff?$|\.svg$|\.ipynb$|\.m$|\.py$", re.I) | |
| # Invasive recordings share the BCI vocabulary that puts them in candidate | |
| # lists, but they are not EEG and their spike files convert to nothing. | |
| INVASIVE = re.compile(r"intracortic|microelectrode.?array|utah.?array|neuropixel" | |
| r"|single.?unit|spiking.?activ|neuroprosthes|implanted.?electrode", re.I) | |
| # Synthetic or simulated signals are not recordings of anyone. | |
| SYNTHETIC = re.compile(r"\bsimulat|\bsynthetic|\bsurrogate\b|\btoy\b|\bmock\b|\bfake\b", re.I) | |
| VOLUME = re.compile(r"^(?P<base>.+?)\.(?:zip\.(?P<n1>\d{2,3})|z(?P<n2>\d{2})|(?P<n3>\d{3}))$", re.I) | |
| def log(*a): | |
| print(*a, flush=True) | |
| def free_gb(path: Path = ROOT) -> float: | |
| return shutil.disk_usage(path).free / 1e9 | |
| def group_volumes(files: list[dict], key_of=lambda f: f["name"]) -> list[tuple[str, list[dict]]]: | |
| """Collapse split archives (foo.zip.001, foo.zip.002, ...) into one unit. | |
| Each volume is useless alone, so they have to be fetched together and | |
| concatenated before anything can be read out of them. | |
| """ | |
| units: dict[str, list[dict]] = {} | |
| order: list[str] = [] | |
| for f in files: | |
| name = key_of(f) | |
| m = VOLUME.match(name) | |
| k = m.group("base") if m else name | |
| if k not in units: | |
| units[k] = [] | |
| order.append(k) | |
| units[k].append(f) | |
| return [(k, sorted(units[k], key=key_of) if len(units[k]) > 1 else units[k]) | |
| for k in order] | |
| def download(url: str, dest: Path, headers: dict | None = None, timeout: int = 3600) -> bool: | |
| """curl handles redirects, retries and resumes better than urllib.""" | |
| dest.parent.mkdir(parents=True, exist_ok=True) | |
| cmd = ["curl", "-sSL", "--fail", "--retry", "3", "--retry-delay", "5", | |
| "--max-time", str(timeout), "-o", str(dest), url] | |
| for k, v in (headers or {}).items(): | |
| cmd[1:1] = ["-H", f"{k}: {v}"] | |
| rc = subprocess.call(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) | |
| return rc == 0 and dest.exists() and dest.stat().st_size > 0 | |
| def unpack(blob: Path, stage: Path) -> Path | None: | |
| """Expand an archive in place, or return the staging dir for a bare file. | |
| Returns None when the format has no extractor on this machine, so the | |
| caller can journal it as skipped rather than silently finding nothing. | |
| """ | |
| ex = stage / "x" | |
| if zipfile.is_zipfile(blob): | |
| with zipfile.ZipFile(blob) as z: | |
| z.extractall(ex) | |
| blob.unlink() | |
| return ex | |
| if tarfile.is_tarfile(blob): | |
| with tarfile.open(blob) as t: | |
| t.extractall(ex, filter="data") | |
| blob.unlink() | |
| return ex | |
| if blob.suffix.lower() == ".7z": | |
| try: | |
| import py7zr | |
| with py7zr.SevenZipFile(blob) as z: | |
| z.extractall(ex) | |
| blob.unlink() | |
| return ex | |
| except ImportError: | |
| pass | |
| if blob.suffix.lower() in (".rar", ".7z"): | |
| for tool, args, pos in (("7z", ["x", "-y", f"-o{ex}"], "end"), | |
| ("7zz", ["x", "-y", f"-o{ex}"], "end"), | |
| ("unar", ["-o", str(ex), "-f"], "end"), | |
| ("unrar", ["x", "-y"], "rar")): | |
| if shutil.which(tool) is None: | |
| continue | |
| ex.mkdir(parents=True, exist_ok=True) | |
| cmd = ([tool] + args + [str(blob)] if pos == "end" | |
| else [tool] + args + [str(blob), str(ex) + "/"]) | |
| if subprocess.call(cmd, stdout=subprocess.DEVNULL, | |
| stderr=subprocess.DEVNULL) == 0: | |
| blob.unlink() | |
| return ex | |
| return None | |
| return stage | |
| def signal_files(root: Path) -> list[Path]: | |
| out = [] | |
| for p in sorted(root.rglob("*")): | |
| if not p.is_file() or p.suffix.lower() not in SIGNAL_EXT: | |
| continue | |
| # BrainVision: .vhdr is the entry point, .eeg/.data is its payload. | |
| stem = p.with_suffix("") | |
| if p.suffix.lower() in (".eeg", ".data") and ( | |
| stem.with_suffix(".vhdr").exists() or stem.with_suffix(".vhdr").exists()): | |
| continue | |
| # EEGLAB: .set is the entry point, .fdt holds the samples. | |
| out.append(p) | |
| return out | |
| def recording_hours(recs: list[dict]) -> float: | |
| """Wall-clock hours covered by the parts of one source recording. | |
| A multi-rate source is split into several EEGX parts covering the same | |
| stretch of time, so the recording lasted as long as its longest part and | |
| never the sum of them. Every ingest measures hours through here, because | |
| when each did its own arithmetic one of them reached for a header key that | |
| does not exist and turned every productive unit into a logged failure. | |
| """ | |
| return max((h["n_samples"] / float(h["sfreq"]) for h in recs), default=0) / 3600 | |
| def unreadable_census(root: Path, top: int = 6) -> str: | |
| """What a barren archive actually held, by extension and bytes. | |
| A unit that yields nothing is otherwise indistinguishable from a unit of | |
| documents, and the whole record gets abandoned on the strength of it. This | |
| says which formats were passed over, so a real gap in the reader shows up | |
| in the log instead of looking like an empty record. | |
| """ | |
| by_ext: dict[str, list] = {} | |
| for p in root.rglob("*"): | |
| if not p.is_file(): | |
| continue | |
| e = p.suffix.lower() or "(none)" | |
| v = by_ext.setdefault(e, [0, 0]) | |
| v[0] += 1 | |
| try: | |
| v[1] += p.stat().st_size | |
| except OSError: | |
| pass | |
| ranked = sorted(by_ext.items(), key=lambda kv: -kv[1][1])[:top] | |
| return ", ".join(f"{e} x{n} ({b/1e6:.0f} MB)" for e, (n, b) in ranked) or "empty" | |
| def convert_tree(ds_name: str, root: Path, prov_base: dict, | |
| out_dir: Path = OUT) -> tuple[int, float]: | |
| from eegx.convert import convert | |
| nfiles = hours = 0 | |
| found = signal_files(root) | |
| if not found: | |
| log(f" (no readable signal; archive holds {unreadable_census(root)})") | |
| for i, sf in enumerate(found): | |
| rel = str(sf.relative_to(root)) | |
| subject = re.sub(r"[^A-Za-z0-9]+", "-", rel.rsplit(".", 1)[0])[:80] or f"f{i}" | |
| try: | |
| recs = convert(sf, out_dir / ds_name, dataset=ds_name, subject=subject, | |
| meta={"source_relpath": rel}, | |
| provenance=dict(prov_base, source_file=rel)) | |
| except Exception as e: | |
| log(f" ! {rel[:60]}: {type(e).__name__}: {str(e)[:90]}") | |
| continue | |
| nfiles += len(recs) | |
| hours += recording_hours(recs) | |
| return nfiles, hours | |
| class Journal: | |
| """Per-unit progress log so an interrupted run never re-downloads.""" | |
| def __init__(self, path: Path): | |
| self.path = path | |
| self.done = set() | |
| if path.exists(): | |
| for line in path.read_text().splitlines(): | |
| try: | |
| r = json.loads(line) | |
| except Exception: | |
| continue | |
| if r.get("status") in ("ok", "skip", "empty"): | |
| self.done.add((r["record"], r["unit"])) | |
| def has(self, record, unit) -> bool: | |
| return (str(record), unit) in self.done | |
| def write(self, **rec): | |
| self.path.parent.mkdir(parents=True, exist_ok=True) | |
| with open(self.path, "a") as f: | |
| f.write(json.dumps(rec) + "\n") | |
| if rec.get("status") in ("ok", "skip", "empty"): | |
| self.done.add((str(rec["record"]), rec["unit"])) | |