add scraper to download txt files from archive.org

src/download_txt_archive_dot_org.py

@@ -0,0 +1,267 @@
+#!/usr/bin/env python3
+# /// script
+# requires-python = ">=3.8"
+# dependencies = [
+#     "requests",
+#     "tqdm",
+# ]
+# ///
+
+from __future__ import annotations
+
+import os
+import re
+import sqlite3
+import threading
+from typing import Any, Dict, Iterable, List, Optional, Sequence, Tuple
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+import requests
+from requests import Session
+from tqdm import tqdm
+
+
+# ----------------------------
+# CONFIG (intentionally globals)
+# ----------------------------
+DB_PATH: str = "archive.org.db"
+DOWNLOAD_DIR: str = "./data/archive-dot-org"               # target download folder
+MIN_DOWNLOADS: int = 1000                    # only download items with downloads >= this
+DATE_START: int = 1880                       # inclusive year
+DATE_END: int = 1882                         # inclusive year
+EXTRA_WHERE: str = (
+    # example: require "science", exclude "religion"
+    # "AND lower(subject) LIKE '%science%' AND lower(subject) NOT LIKE '%religion%'"
+    # Exclude religious texts
+    "AND LOWER(subject) NOT LIKE '%baptist%' "
+    "AND LOWER(subject) NOT LIKE '%church%' "
+    "AND LOWER(subject) NOT LIKE '%congregation%'"
+    "AND LOWER(subject) NOT LIKE '%methodis%'"
+    "AND LOWER(subject) NOT LIKE '%religio%'"
+    "AND LOWER(subject) NOT LIKE '%christ%'"
+    "AND LOWER(subject) NOT LIKE '%protestant%'"
+    "AND LOWER(subject) NOT LIKE '%evangelical%'"
+    "AND LOWER(subject) NOT LIKE '%bible%'"
+    "AND LOWER(subject) NOT LIKE '%theology%'"
+    "AND LOWER(subject) NOT LIKE '%hymn%'"
+    "AND LOWER(subject) NOT LIKE '%theism%'"
+    # Exclude newspapers, periodicals, etc
+    "AND LOWER(subject) NOT LIKE '%newspaper%'"
+    "AND LOWER(subject) NOT LIKE '%tribune%'"
+    "AND LOWER(subject) NOT LIKE '%herald%'"
+
+)
+LIMIT_ITEMS: int = 10_000                    # hard cap to avoid runaway
+MAX_WORKERS: int = 2                         # parallel downloads
+REQUEST_TIMEOUT_S: float = 30.0              # per HTTP request
+REQUEST_RETRIES: int = 3                     # retry on transient errors
+
+def build_sql_query(
+    min_downloads: int,
+    year_start: int,
+    year_end: int,
+    extra_where_sql: str,
+    limit_items: int,
+) -> Tuple[str, Tuple]:
+    assert year_start <= year_end
+    # Extract first 4 digits from `date` safely; skip rows without a 4-digit year.
+    base_where = (
+        "WHERE downloads >= ? "
+        "AND date IS NOT NULL "
+        "AND substr(date,1,4) GLOB '[0-9][0-9][0-9][0-9]' "
+        "AND CAST(substr(date,1,4) AS INTEGER) BETWEEN ? AND ? "
+    )
+    params: Tuple = (min_downloads, year_start, year_end)
+    # Extra WHERE is injected as a trusted constant by the user (not parameterized).
+    where_clause = base_where + (f" {extra_where_sql} " if extra_where_sql.strip() else "")
+    sql = (
+        "SELECT identifier FROM items "
+        + where_clause
+        + "ORDER BY downloads DESC, identifier ASC "
+        + "LIMIT ?"
+    )
+    params = params + (limit_items,)
+    return sql, params
+
+
+def list_identifiers(
+    db_path: str,
+    min_downloads: int,
+    year_start: int,
+    year_end: int,
+    extra_where_sql: str,
+    limit_items: int,
+) -> List[str]:
+    sql, params = build_sql_query(min_downloads, year_start, year_end, extra_where_sql, limit_items)
+    with sqlite3.connect(db_path) as conn:
+        conn.row_factory = lambda cur, row: row[0]
+        rows: List[str] = conn.execute(sql, params).fetchall()
+    return rows
+
+
+def http_get_json_with_retries(
+    session: Session,
+    url: str,
+    params: Optional[Sequence[Tuple[str, Any]]] = None,
+    timeout_s: float = REQUEST_TIMEOUT_S,
+    retries: int = REQUEST_RETRIES,
+) -> Dict[str, Any]:
+    attempt = 0
+    backoff = 1.0
+    while True:
+        try:
+            resp = session.get(url, params=params, timeout=timeout_s, verify=True)
+            resp.raise_for_status()
+            return resp.json()
+        except (requests.exceptions.Timeout, requests.exceptions.ConnectionError, requests.exceptions.HTTPError):
+            attempt += 1
+            if attempt > retries:
+                raise
+            _sleep(backoff)
+            backoff *= 2.0
+
+
+def http_stream_download(
+    session: Session,
+    url: str,
+    dest_path: str,
+    timeout_s: float = REQUEST_TIMEOUT_S,
+    retries: int = REQUEST_RETRIES,
+) -> None:
+    # Stream to temp file; atomic rename at end.
+    tmp_path = dest_path + ".part"
+    attempt = 0
+    backoff = 1.0
+    while True:
+        try:
+            with session.get(url, stream=True, timeout=timeout_s, verify=True) as r:
+                r.raise_for_status()
+                os.makedirs(os.path.dirname(dest_path), exist_ok=True)
+                with open(tmp_path, "wb") as f:
+                    for chunk in r.iter_content(chunk_size=1024 * 1024):
+                        if chunk:
+                            f.write(chunk)
+            os.replace(tmp_path, dest_path)
+            return
+        except (requests.exceptions.Timeout, requests.exceptions.ConnectionError, requests.exceptions.HTTPError):
+            attempt += 1
+            if attempt > retries:
+                # Clean partial
+                with _suppress():
+                    os.remove(tmp_path)
+                raise
+            _sleep(backoff)
+            backoff *= 2.0
+
+
+def choose_txt_file(files: List[Dict[str, Any]]) -> Optional[Dict[str, Any]]:
+    # Prefer the largest .txt file; fall back to any .txt.
+    txts = [f for f in files if isinstance(f.get("name"), str) and f["name"].lower().endswith(".txt")]
+    if not txts:
+        return None
+    def file_size(f: Dict[str, Any]) -> int:
+        try:
+            return int(f.get("size", 0))
+        except Exception:
+            return 0
+    txts.sort(key=file_size, reverse=True)
+    return txts[0]
+
+
+def fetch_txt_for_identifier(session: Session, identifier: str) -> Optional[Tuple[str, str]]:
+    # Return (filename, download_url) or None.
+    meta_url = f"https://archive.org/metadata/{identifier}"
+    data = http_get_json_with_retries(session, meta_url)
+    meta = data.get('metadata', {})
+    date = meta.get('date', 'undated')
+    if type(date) is list:
+        date = str(sorted(date)[0])
+    print(f"Fetched metadata for `{meta.get('title')}` by `{meta.get('creator')}`")
+    files = data.get("files", [])
+    if not isinstance(files, list):
+        return None
+    chosen = choose_txt_file(files)
+    if not chosen:
+        return None
+    name = chosen["name"]
+    # Prefer canonical /download URL
+    url = f"https://archive.org/download/{identifier}/{name}"
+    return name, url, date
+
+
+def sanitize_identifier(identifier: str) -> str:
+    # Keep filesystem safe
+    return re.sub(r"[^A-Za-z0-9._-]+", "_", identifier)
+
+
+def download_one(session: Session, base_dir: str, identifier: str) -> Tuple[str, bool, Optional[str]]:
+    try:
+        # subdir = os.path.join(base_dir, sanitize_identifier(identifier))
+        # os.makedirs(subdir, exist_ok=True)
+        meta = fetch_txt_for_identifier(session, identifier)
+        if not meta:
+            return identifier, None, False, "no .txt file found"
+        filename, url, date = meta
+        dest = os.path.join(base_dir, str(date)[:4], filename)
+        if os.path.exists(dest) and os.path.getsize(dest) > 0:
+            return identifier, None, True, "exists"
+        http_stream_download(session, url, dest)
+        # print(f"\nDownloaded {url}")
+        return identifier, date, True, None
+    except Exception as e:
+        return identifier, None, False, str(e)
+
+
+def _sleep(seconds: float) -> None:
+    import time as _t
+    _t.sleep(seconds)
+
+
+class _suppress:
+    def __enter__(self):
+        return self
+    def __exit__(self, exc_type, exc, tb):
+        return True
+
+
+def run() -> None:
+    identifiers = list_identifiers(
+        DB_PATH,
+        MIN_DOWNLOADS,
+        DATE_START,
+        DATE_END,
+        EXTRA_WHERE,
+        LIMIT_ITEMS,
+    )
+    if not identifiers:
+        print("No identifiers match the filters.")
+        return
+
+    session = requests.Session()
+    lock = threading.Lock()
+    success_count = 0
+    skip_count = 0
+    fail_count = 0
+
+    with ThreadPoolExecutor(max_workers=MAX_WORKERS) as pool, tqdm(total=len(identifiers), desc="download", unit=" item") as bar:
+        futures = [pool.submit(download_one, session, DOWNLOAD_DIR, ident) for ident in identifiers]
+        for f in as_completed(futures):
+            ident, date, ok, msg = f.result()
+            bar.set_description(f"[{date}] downloaded {ident} {ok=} {msg=}")
+            with lock:
+                if ok and msg == "exists":
+                    skip_count += 1
+                elif ok:
+                    success_count += 1
+                else:
+                    fail_count += 1
+            bar.update(1)
+            if not ok and msg:
+                bar.write(f"[FAIL] {ident}: {msg}")
+
+    print(f"done: success={success_count} skipped={skip_count} failed={fail_count}")
+
+
+if __name__ == "__main__":
+    run()
+