| from __future__ import annotations |
|
|
| import argparse |
| import datetime as dt |
| import os |
| import re |
| import sys |
| import time |
| import urllib.error |
| import urllib.request |
| from concurrent.futures import ThreadPoolExecutor, as_completed |
| from dataclasses import dataclass |
| from pathlib import Path |
|
|
| BASE_URL_DEFAULT = "https://axavier.org/UnitCommitment.jl/0.4/instances" |
|
|
|
|
| @dataclass(frozen=True) |
| class Task: |
| case: str |
| date: dt.date |
| url: str |
| out_path: Path |
|
|
|
|
| def _iter_dates(start: dt.date, end: dt.date): |
| if end < start: |
| raise ValueError("end_date must be >= start_date") |
| cur = start |
| one = dt.timedelta(days=1) |
| while cur <= end: |
| yield cur |
| cur += one |
|
|
|
|
| def _default_instances_md_path() -> Path: |
| here = Path(__file__).resolve() |
| project_root = here.parents[2] |
| return project_root / "docs" / "src" / "guides" / "instances.md" |
|
|
|
|
| def _parse_matpower_cases_from_instances_md(instances_md_path: Path) -> list[str]: |
| text = instances_md_path.read_text(encoding="utf-8") |
| pattern = re.compile(r"matpower/(case[^/\s`]+)/\d{4}-\d{2}-\d{2}") |
| cases = sorted(set(pattern.findall(text))) |
| if not cases: |
| raise RuntimeError(f"No MATPOWER cases found in {instances_md_path}") |
| return cases |
|
|
|
|
| def _download_one(task: Task, timeout_s: float, retries: int, force: bool) -> tuple[str, str | None]: |
| task.out_path.parent.mkdir(parents=True, exist_ok=True) |
|
|
| if task.out_path.exists() and not force and task.out_path.stat().st_size > 0: |
| return ("skipped", None) |
|
|
| tmp_path = task.out_path.with_suffix(task.out_path.suffix + ".part") |
| req = urllib.request.Request(task.url, headers={"User-Agent": "UnitCommitment downloader"}) |
|
|
| last_err = None |
| for attempt in range(retries + 1): |
| try: |
| with urllib.request.urlopen(req, timeout=timeout_s) as resp: |
| with open(tmp_path, "wb") as f: |
| while True: |
| chunk = resp.read(1024 * 256) |
| if not chunk: |
| break |
| f.write(chunk) |
| os.replace(tmp_path, task.out_path) |
| return ("downloaded", None) |
| except (urllib.error.URLError, urllib.error.HTTPError, TimeoutError, OSError) as e: |
| last_err = e |
| try: |
| if tmp_path.exists(): |
| tmp_path.unlink() |
| except OSError: |
| pass |
| if attempt < retries: |
| time.sleep(min(10.0, 0.5 * (2**attempt))) |
| continue |
| return ("failed", f"{type(last_err).__name__}: {last_err}") |
|
|
| return ("failed", f"{type(last_err).__name__}: {last_err}") |
|
|
|
|
| def _build_tasks( |
| base_url: str, |
| out_dir: Path, |
| cases: list[str], |
| start_date: dt.date, |
| end_date: dt.date, |
| ) -> list[Task]: |
| tasks: list[Task] = [] |
| for case in cases: |
| for d in _iter_dates(start_date, end_date): |
| date_str = d.isoformat() |
| url = f"{base_url}/matpower/{case}/{date_str}.json.gz" |
| out_path = out_dir / case / f"{date_str}.json.gz" |
| tasks.append(Task(case=case, date=d, url=url, out_path=out_path)) |
| return tasks |
|
|
|
|
| def _parse_date(s: str) -> dt.date: |
| return dt.date.fromisoformat(s) |
|
|
|
|
| def main(argv: list[str]) -> int: |
| parser = argparse.ArgumentParser() |
| parser.add_argument("--instances-md", type=Path, default=_default_instances_md_path()) |
| parser.add_argument("--base-url", type=str, default=BASE_URL_DEFAULT) |
| parser.add_argument( |
| "--out-dir", |
| type=Path, |
| default=(Path(__file__).resolve().parents[2] / "instances" / "matpower"), |
| ) |
| parser.add_argument("--start-date", type=_parse_date, default=dt.date(2017, 1, 1)) |
| parser.add_argument("--end-date", type=_parse_date, default=dt.date(2017, 12, 31)) |
| parser.add_argument("--workers", type=int, default=min(32, (os.cpu_count() or 4) * 4)) |
| parser.add_argument("--timeout", type=float, default=60.0) |
| parser.add_argument("--retries", type=int, default=3) |
| parser.add_argument("--force", action="store_true") |
| parser.add_argument("--dry-run", action="store_true") |
| parser.add_argument("--list-cases", action="store_true") |
| args = parser.parse_args(argv) |
|
|
| instances_md_path: Path = args.instances_md |
| if not instances_md_path.exists(): |
| raise FileNotFoundError(str(instances_md_path)) |
|
|
| cases = _parse_matpower_cases_from_instances_md(instances_md_path) |
| if args.list_cases: |
| for c in cases: |
| print(c) |
| return 0 |
|
|
| out_dir: Path = args.out_dir |
| tasks = _build_tasks( |
| base_url=args.base_url.rstrip("/"), |
| out_dir=out_dir, |
| cases=cases, |
| start_date=args.start_date, |
| end_date=args.end_date, |
| ) |
|
|
| print(f"cases={len(cases)} files={len(tasks)} out_dir={out_dir}") |
| if args.dry_run: |
| for t in tasks[:10]: |
| print(f"{t.url} -> {t.out_path}") |
| if len(tasks) > 10: |
| print("...") |
| return 0 |
|
|
| downloaded = 0 |
| skipped = 0 |
| failed = 0 |
| total = len(tasks) |
| t0 = time.time() |
| last_print = 0.0 |
|
|
| with ThreadPoolExecutor(max_workers=max(1, args.workers)) as ex: |
| fut_to_task = { |
| ex.submit(_download_one, t, args.timeout, args.retries, args.force): t for t in tasks |
| } |
| for i, fut in enumerate(as_completed(fut_to_task), start=1): |
| status, err = fut.result() |
| if status == "downloaded": |
| downloaded += 1 |
| elif status == "skipped": |
| skipped += 1 |
| else: |
| failed += 1 |
| task = fut_to_task[fut] |
| sys.stderr.write(f"FAILED {task.url} -> {task.out_path} ({err})\n") |
|
|
| now = time.time() |
| if now - last_print >= 1.0 or i == total: |
| elapsed = max(0.001, now - t0) |
| rate = i / elapsed |
| print( |
| f"{i}/{total} downloaded={downloaded} skipped={skipped} failed={failed} rate={rate:.1f}/s" |
| ) |
| last_print = now |
|
|
| if failed: |
| return 2 |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| raise SystemExit(main(sys.argv[1:])) |
|
|
