Datasets:

beyarkay
/

pre-1950s-text

@@ -1,104 +1,307 @@
 # /// script
-# requires-python = ">=3.11"
-# dependencies = ["tqdm", "sqlite3"]
 # ///
-import csv
-import urllib.parse
-import urllib.request
-from pathlib import Path
-from datetime import date, timedelta
 from tqdm import tqdm
-# Create an index of archive.org identifiers of possibly useful text documents.
-# Store all the indices in a sqlite3 DB
-# make it parallel, so we can download faster
-# Avoid the 10k item limit by having as large a range as possible, then
-# reducing the range down until we have less than 10k
-#
-BASE_URL = "https://archive.org/advancedsearch.php"
-FIELDS = ["creator", "date", "downloads", "identifier", "item_size", "subject", "title"]
-ROWS_PER_PAGE = 1000
-QUERY = f'mediatype:(texts) AND (language:eng OR language:"English") AND (date:[1600-01-01 TO 1949-12-31] OR year:[1600 TO 1949]) AND downloads:[5 TO *]'
-QUERY = 'mediatype:(texts) AND (language:eng OR language:"English") AND (date:[1600-01-01 TO 1949-12-31] OR year:[1600 TO 1950]) AND downloads:[5 TO *] AND format:("Full Text" OR "txt" OR "text")'
-OUT_ROOT = Path("data/archive-dot-org/indices")
-BY_YEAR = OUT_ROOT / "by_year"
-BY_DAY = OUT_ROOT / "by_day"
-BY_YEAR.mkdir(parents=True, exist_ok=True)
-BY_DAY.mkdir(parents=True, exist_ok=True)
-def parse_csv(body: str) -> list[dict]:
-    lines = body.strip().splitlines()
-    if not lines or lines[0].startswith('<!DOCTYPE html>'):
-        return []
-    reader = csv.DictReader(lines)
-    return list(reader)
-def fetch_range(start: str, end: str, pbar=None) -> list[dict]:
-    all_rows = []
-    page = 1
-    while True:
-        if pbar is not None:
-            pbar.set_description(f"Fetching {start} page {page}")
-        params = {
-            'q': QUERY,
-            'fl[]': FIELDS,
-            'sort[]': 'date asc',
-            'rows': str(ROWS_PER_PAGE),
-            'page': str(page),
-            'output': 'csv',
-        }
-        url = BASE_URL + '?' + urllib.parse.urlencode(params, doseq=True)
         try:
-            with urllib.request.urlopen(url) as r:
-                body = r.read().decode('utf-8')
-        except Exception as e:
-            print(f"  Failed {start}–{end} page {page}: {e}")
-            break
-        rows = parse_csv(body)
-        if not rows:
             break
-        all_rows.extend(rows)
-        if len(rows) < ROWS_PER_PAGE:
             break
-        page += 1
-    return all_rows
-# 1. Pre-1860: yearly
-pbar = tqdm(range(1600, 1860), desc="Year bins")
-for year in pbar:
-    out_file = BY_YEAR / f"{year}.csv"
-    if out_file.exists():
-        continue
-    pbar.set_description(f"Fetching {year}")
-    rows = fetch_range(f"{year}-01-01", f"{year}-12-31", pbar=pbar)
-    if rows:
-        pbar.set_description(f"Fetching {year} (writing {len(rows)} rows)")
-        with out_file.open("w", newline='', encoding="utf-8") as f:
-            writer = csv.DictWriter(f, fieldnames=FIELDS)
-            writer.writeheader()
-            writer.writerows(rows)
-# 2. 1860–1949: daily
-start_date = date(1860, 1, 1)
-end_date = date(1950, 1, 1)
-cur = start_date
-pbar = tqdm(total=(end_date - start_date).days, desc="Daily bins")
-while cur < end_date:
-    day_str = cur.isoformat()
-    out_file = BY_DAY / f"{day_str}.csv"
-    if not out_file.exists():
-        pbar.set_description(f"Fetching {day_str}")
-        rows = fetch_range(day_str, day_str, pbar=pbar)
-        if rows:
-            pbar.set_description(f"Fetching {day_str} (writing {len(rows)} rows)")
-            with out_file.open("w", newline='', encoding="utf-8") as f:
-                writer = csv.DictWriter(f, fieldnames=FIELDS)
-                writer.writeheader()
-                writer.writerows(rows)
-    cur += timedelta(days=1)
-    pbar.update(1)

+#!/usr/bin/env python3
 # /// script
+# requires-python = ">=3.8"
+# dependencies = [
+#     "requests",
+#     "tqdm",
+# ]
 # ///
+from __future__ import annotations
+import contextlib
+import datetime as dt
+import json
+import queue
+import sqlite3
+import threading
+from typing import Any, Dict, Iterable, List, Optional, Sequence, Tuple
+from concurrent.futures import ThreadPoolExecutor, as_completed
+import time as _time
+import requests
+from requests import Session
 from tqdm import tqdm
+def build_query(start_date: dt.date, end_date: dt.date) -> str:
+    assert start_date <= end_date
+    start_iso = start_date.isoformat()
+    end_iso = end_date.isoformat()
+    return (
+        'mediatype:(texts) '
+        'AND (language:eng OR language:"English") '
+        f'AND (date:[{start_iso} TO {end_iso}] OR year:[{start_date.year} TO {end_date.year}]) '
+        # 'AND downloads:[5 TO *] '
+        'AND format:("Full Text" OR "txt" OR "text")'
+    )
+def http_get_json(
+    session: Session,
+    url: str,
+    params: Sequence[Tuple[str, Any]],
+    timeout_seconds: float,
+    retries: int,
+) -> Dict[str, Any]:
+    print(f"\nRequesting from {url} {params}")
+    backoff = 1.0
+    for attempt in range(retries + 1):
         try:
+            resp = session.get(url, params=params, timeout=timeout_seconds)
+            resp.raise_for_status()
+            return resp.json()
+        except requests.exceptions.Timeout as e:
+            print(f"Exception: {e}, {url=} {params=}")
+            if attempt == retries:
+                raise
+            _time.sleep(backoff)
+            backoff *= 2.0
+        except requests.exceptions.ConnectionError as e:
+            print(f"Exception: {e}, {url=} {params=}")
+            if attempt == retries:
+                raise
+            _time.sleep(backoff)
+            backoff *= 2.0
+        except requests.exceptions.HTTPError as e:
+            print(f"Exception: {e}, {url=} {params=}")
+            code = e.response.status_code if e.response is not None else None
+            if code is not None and 500 <= code < 600 and attempt < retries:
+                _time.sleep(backoff)
+                backoff *= 2.0
+                continue
+            raise
+        except json.JSONDecodeError as e:
+            print(f"Exception: {e}, {url=} {params=}")
+            if attempt == retries:
+                raise
+            _time.sleep(backoff)
+            backoff *= 2.0
+    raise RuntimeError("unreachable")
+def scrape_total_only(
+    session: Session,
+    endpoint: str,
+    query: str,
+    timeout_seconds: float,
+    retries: int,
+) -> int:
+    params: List[Tuple[str, Any]] = [
+        ("q", query),
+        ("total_only", "true"),
+        # count is optional when total_only=true; include to be explicit and satisfy min constraint.
+        ("count", 100),
+    ]
+    data = http_get_json(session, endpoint, params, timeout_seconds, retries)
+    total = int(data.get("total", 0))
+    assert total >= 0
+    return total
+def month_ranges(start_date: dt.date, end_date: dt.date) -> List[Tuple[dt.date, dt.date]]:
+    assert start_date <= end_date
+    ranges: List[Tuple[dt.date, dt.date]] = []
+    y, m = start_date.year, start_date.month
+    end_ym = (end_date.year, end_date.month)
+    while (y, m) <= end_ym:
+        first = dt.date(y, m, 1)
+        if m == 12:
+            next_month = dt.date(y + 1, 1, 1)
+        else:
+            next_month = dt.date(y, m + 1, 1)
+        last = min(next_month - dt.timedelta(days=1), end_date)
+        if first < start_date:
+            first = start_date
+        ranges.append((first, last))
+        if m == 12:
+            y, m = y + 1, 1
+        else:
+            m += 1
+    return ranges
+def ensure_schema(connection: sqlite3.Connection) -> None:
+    connection.execute(
+        """
+        CREATE TABLE IF NOT EXISTS items (
+            identifier TEXT PRIMARY KEY,
+            title TEXT,
+            creator TEXT,
+            date TEXT,
+            downloads INTEGER,
+            item_size INTEGER,
+            subject TEXT
+        )
+        """
+    )
+    connection.commit()
+def coerce_str(value: Any) -> Optional[str]:
+    if value is None:
+        return None
+    if isinstance(value, list):
+        return "; ".join(str(x) for x in value if x is not None)
+    return str(value)
+def coerce_int(value: Any) -> Optional[int]:
+    if value is None:
+        return None
+    try:
+        return int(value)
+    except (ValueError, TypeError):
+        return None
+def docs_to_rows(docs: Iterable[Dict[str, Any]]) -> List[Tuple]:
+    rows: List[Tuple] = []
+    for d in docs:
+        identifier = coerce_str(d.get("identifier"))
+        if not identifier:
+            continue
+        title = coerce_str(d.get("title"))
+        creator = coerce_str(d.get("creator"))
+        date_val = coerce_str(d.get("date"))
+        subject = coerce_str(d.get("subject"))
+        downloads = coerce_int(d.get("downloads"))
+        item_size = coerce_int(d.get("item_size"))
+        rows.append((identifier, title, creator, date_val, downloads, item_size, subject))
+    return rows
+def writer_loop(
+    database_path: str,
+    input_queue: "queue.Queue[Optional[List[Tuple]]]",
+    commit_batch_size: int,
+) -> None:
+    with contextlib.closing(sqlite3.connect(database_path, timeout=30.0)) as conn:
+        ensure_schema(conn)
+        pending: List[Tuple] = []
+        while True:
+            item = input_queue.get()
+            if item is None:
+                if pending:
+                    conn.executemany(
+                        "INSERT OR REPLACE INTO items(identifier, title, creator, date, downloads, item_size, subject) VALUES(?,?,?,?,?,?,?)",
+                        pending,
+                    )
+                    conn.commit()
+                break
+            pending.extend(item)
+            if len(pending) >= commit_batch_size:
+                conn.executemany(
+                    "INSERT OR REPLACE INTO items(identifier, title, creator, date, downloads, item_size, subject) VALUES(?,?,?,?,?,?,?)",
+                    pending,
+                )
+                conn.commit()
+                pending.clear()
+def scrape_month_cursor_loop(
+    session: Session,
+    endpoint: str,
+    query: str,
+    fields: Sequence[str],
+    batch_count: int,
+    timeout_seconds: float,
+    retries: int,
+    rows_out: "queue.Queue[Optional[List[Tuple]]]",
+    items_bar: tqdm,
+) -> None:
+    print(f"\nRequesting {batch_count} from {endpoint} {query}")
+    params_base: Dict[str, Any] = {
+        "q": query,
+        "fields": ",".join(fields),
+        "count": batch_count,
+    }
+    params = list(params_base.items())
+    try:
+        data = http_get_json(session, endpoint, params, timeout_seconds, retries)
+    except (requests.exceptions.RequestException, json.JSONDecodeError):
+        return
+    while True:
+        docs = data.get("items", [])
+        if docs:
+            rows = docs_to_rows(docs)
+            if rows:
+                rows_out.put(rows)
+            items_bar.update(len(docs))
+            # items_bar.set_description(f"items ({docs.get('date')})")
+        cursor = data.get("cursor")
+        if not cursor:
             break
+        params = list(params_base.items()) + [("cursor", cursor)]
+        try:
+            data = http_get_json(session, endpoint, params, timeout_seconds, retries)
+        except (requests.exceptions.RequestException, json.JSONDecodeError):
             break
+def run() -> None:
+    database_path = "archive.org.db"
+    endpoint = "https://archive.org/services/search/v1/scrape"
+    start_date = dt.date(1881, 1, 1)
+    end_date = dt.date(1881, 1, 2)
+    batch_count = 10000  # scraping API requires count >= 100
+    request_timeout_seconds = 20.0
+    request_retries = 5
+    writer_commit_batch_size = 500
+    max_workers = 2
+    fields = ["creator", "date", "downloads", "identifier", "item_size", "subject", "title"]
+    session = requests.Session()
+    # Plan monthly queries and totals
+    monthly_queries: List[Tuple[str, int]] = []
+    months = month_ranges(start_date, end_date)
+    with tqdm(desc="planning-months", total=len(months), unit="month") as plan_bar:
+        for m_start, m_end in months:
+            q = build_query(m_start, m_end)
+            try:
+                total = scrape_total_only(session, endpoint, q, request_timeout_seconds, request_retries)
+            except (requests.exceptions.RequestException, json.JSONDecodeError):
+                total = 0
+            monthly_queries.append((q, total))
+            plan_bar.update(1)
+    total_items = sum(t for _, t in monthly_queries)
+    rows_queue: "queue.Queue[Optional[List[Tuple]]]" = queue.Queue(maxsize=max_workers * 4)
+    writer_thread = threading.Thread(
+        target=writer_loop,
+        args=(database_path, rows_queue, writer_commit_batch_size),
+        daemon=True,
+    )
+    writer_thread.start()
+    with tqdm(total=total_items if total_items > 0 else None, desc="items", unit="it") as items_bar, \
+         ThreadPoolExecutor(max_workers=max_workers) as pool:
+        futures = []
+        for q, total in monthly_queries:
+            futures.append(
+                pool.submit(
+                    scrape_month_cursor_loop,
+                    session, endpoint, q, fields, batch_count,
+                    request_timeout_seconds, request_retries,
+                    rows_queue, items_bar,
+                )
+            )
+        for f in as_completed(futures):
+            try:
+                # f.get(timeout=None)
+                f.result()
+            except Exception:
+                raise
+    rows_queue.put(None)
+    writer_thread.join()
+if __name__ == "__main__":
+    run()

src/download_archive_dot_org2.py DELETED Viewed

@@ -1,378 +0,0 @@
-#!/usr/bin/env python3
-# /// script
-# requires-python = ">=3.8"
-# dependencies = [
-#     "requests",
-#     "tqdm",
-# ]
-# ///
-from __future__ import annotations
-import contextlib
-import datetime as dt
-import json
-import math
-import queue
-import sqlite3
-import threading
-from typing import Any, Dict, Iterable, List, Optional, Sequence, Tuple
-from concurrent.futures import ThreadPoolExecutor, as_completed
-import time as _time
-import requests
-from requests import Session
-from tqdm import tqdm
-def build_query(start_date: dt.date, end_date: dt.date) -> str:
-    assert start_date <= end_date
-    start_iso = start_date.isoformat()
-    end_iso = end_date.isoformat()
-    return (
-        'mediatype:(texts) '
-        'AND (language:eng OR language:"English") '
-        f'AND (date:[{start_iso} TO {end_iso}] OR year:[{start_date.year} TO {end_date.year}]) '
-        'AND downloads:[5 TO *] '
-        'AND format:("Full Text" OR "txt" OR "text")'
-    )
-def http_get_json(
-    session: Session,
-    url: str,
-    params: Sequence[Tuple[str, Any]],
-    timeout_seconds: float,
-    retries: int,
-) -> Dict[str, Any]:
-    print(f"\nFetching {url} {params}")
-    backoff = 1.0
-    for attempt in range(retries + 1):
-        try:
-            resp = session.get(url, params=params, timeout=timeout_seconds)
-            resp.raise_for_status()
-            return resp.json()
-        except requests.exceptions.Timeout as e:
-            if attempt == retries:
-                raise
-            print(f"\n  Timed out requesting {url}, sleeping")
-            _sleep(backoff)
-            backoff *= 2.0
-        except requests.exceptions.ConnectionError as e:
-            if attempt == retries:
-                raise
-            print(f"\n  Connection error requesting {url}, sleeping")
-            _sleep(backoff)
-            backoff *= 2.0
-        except requests.exceptions.HTTPError as e:
-            code = e.response.status_code if e.response is not None else None
-            if code is not None and 500 <= code < 600 and attempt < retries:
-                print(f"\n  HTTP Error, sleeping {url} {params}: {e}")
-                _sleep(backoff)
-                backoff *= 2.0
-                continue
-            raise
-        except json.JSONDecodeError as e:
-            print(f"\n  JSON decode error requesting {url}, sleeping")
-            if attempt == retries:
-                raise
-            _sleep(backoff)
-            backoff *= 2.0
-    raise RuntimeError("unreachable after retry loop")
-def _sleep(seconds: float) -> None:
-    # Local import to avoid global state
-    _time.sleep(seconds)
-def probe_count(session: Session, query: str, timeout_seconds: float, retries: int) -> int:
-    url = "https://archive.org/advancedsearch.php"
-    params: List[Tuple[str, Any]] = [
-        ("q", query),
-        ("rows", 0),
-        ("page", 1),
-        ("output", "json"),
-    ]
-    data = http_get_json(session, url, params, timeout_seconds, retries)
-    response = data.get("response", {})
-    num_found = int(response.get("numFound", 0))
-    assert num_found >= 0
-    return num_found
-def enumerate_pages(num_found: int, rows_per_page: int) -> List[int]:
-    assert rows_per_page > 0
-    if num_found == 0:
-        return []
-    return list(range(1, math.ceil(num_found / rows_per_page) + 1))
-def fetch_page_docs(
-    session: Session,
-    query: str,
-    page_number: int,
-    rows_per_page: int,
-    timeout_seconds: float,
-    retries: int,
-    fields: Sequence[str],
-) -> List[Dict[str, Any]]:
-    url = "https://archive.org/advancedsearch.php"
-    params: List[Tuple[str, Any]] = [
-        ("q", query),
-        ("rows", rows_per_page),
-        ("page", page_number),
-        ("output", "json"),
-    ] + [("fl[]", f) for f in fields]
-    data = http_get_json(session, url, params, timeout_seconds, retries)
-    docs = data.get("response", {}).get("docs", [])
-    assert isinstance(docs, list)
-    return docs
-def month_ranges(start_date: dt.date, end_date: dt.date) -> List[Tuple[dt.date, dt.date]]:
-    assert start_date <= end_date
-    ranges: List[Tuple[dt.date, dt.date]] = []
-    y, m = start_date.year, start_date.month
-    end_ym = (end_date.year, end_date.month)
-    while (y, m) <= end_ym:
-        first = dt.date(y, m, 1)
-        if m == 12:
-            next_month = dt.date(y + 1, 1, 1)
-        else:
-            next_month = dt.date(y, m + 1, 1)
-        last = min(next_month - dt.timedelta(days=1), end_date)
-        if first < start_date:
-            first = start_date
-        ranges.append((first, last))
-        if m == 12:
-            y, m = y + 1, 1
-        else:
-            m += 1
-    return ranges
-def split_date_range(start_date: dt.date, end_date: dt.date) -> Tuple[Tuple[dt.date, dt.date], Tuple[dt.date, dt.date]]:
-    assert start_date <= end_date
-    if start_date == end_date:
-        raise ValueError("cannot split a single day further")
-    total_days = (end_date - start_date).days
-    mid = start_date + dt.timedelta(days=total_days // 2)
-    left = (start_date, mid)
-    right = (mid + dt.timedelta(days=1), end_date)
-    return left, right
-def plan_queries_by_date(
-    session: Session,
-    start_date: dt.date,
-    end_date: dt.date,
-    timeout_seconds: float,
-    retries: int,
-) -> List[Tuple[str, int]]:
-    planned: List[Tuple[str, int]] = []
-    for m_start, m_end in month_ranges(start_date, end_date):
-        _plan_queries_recursive(session, m_start, m_end, planned, timeout_seconds, retries)
-    return planned
-def _plan_queries_recursive(
-    session: Session,
-    start_date: dt.date,
-    end_date: dt.date,
-    planned: List[Tuple[str, int]],
-    timeout_seconds: float,
-    retries: int,
-) -> None:
-    q = build_query(start_date, end_date)
-    count = probe_count(session, q, timeout_seconds, retries)
-    if count == 10000 and start_date < end_date:
-        left, right = split_date_range(start_date, end_date)
-        _plan_queries_recursive(session, left[0], left[1], planned, timeout_seconds, retries)
-        _plan_queries_recursive(session, right[0], right[1], planned, timeout_seconds, retries)
-    else:
-        # If single day still 10k, accept loss; advancedsearch caps results.
-        planned.append((q, count))
-def ensure_schema(connection: sqlite3.Connection) -> None:
-    connection.execute(
-        """
-        CREATE TABLE IF NOT EXISTS items (
-            identifier TEXT PRIMARY KEY,
-            title TEXT,
-            creator TEXT,
-            date TEXT,
-            downloads INTEGER,
-            item_size INTEGER,
-            subject TEXT
-        )
-        """
-    )
-    connection.commit()
-def coerce_str(value: Any) -> Optional[str]:
-    if value is None:
-        return None
-    if isinstance(value, list):
-        return "; ".join(str(x) for x in value if x is not None)
-    return str(value)
-def coerce_int(value: Any) -> Optional[int]:
-    if value is None:
-        return None
-    try:
-        return int(value)
-    except (ValueError, TypeError):
-        return None
-def docs_to_rows(docs: Iterable[Dict[str, Any]]) -> List[Tuple]:
-    rows: List[Tuple] = []
-    for d in docs:
-        identifier = coerce_str(d.get("identifier"))
-        if not identifier:
-            continue
-        title = coerce_str(d.get("title"))
-        creator = coerce_str(d.get("creator"))
-        date_val = coerce_str(d.get("date"))
-        subject = coerce_str(d.get("subject"))
-        downloads = coerce_int(d.get("downloads"))
-        item_size = coerce_int(d.get("item_size"))
-        rows.append((identifier, title, creator, date_val, downloads, item_size, subject))
-    return rows
-def writer_loop(
-    database_path: str,
-    input_queue: "queue.Queue[Optional[List[Tuple]]]",
-    commit_batch_size: int,
-) -> None:
-    with contextlib.closing(sqlite3.connect(database_path, timeout=30.0)) as conn:
-        ensure_schema(conn)
-        pending: List[Tuple] = []
-        while True:
-            item = input_queue.get()
-            if item is None:
-                if pending:
-                    try:
-                        conn.executemany(
-                            "INSERT OR REPLACE INTO items(identifier, title, creator, date, downloads, item_size, subject) VALUES(?,?,?,?,?,?,?)",
-                            pending,
-                        )
-                    except sqlite3.DatabaseError as e:
-                        raise
-                    conn.commit()
-                break
-            pending.extend(item)
-            if len(pending) >= commit_batch_size:
-                try:
-                    conn.executemany(
-                        "INSERT OR REPLACE INTO items(identifier, title, creator, date, downloads, item_size, subject) VALUES(?,?,?,?,?,?,?)",
-                        pending,
-                    )
-                except sqlite3.DatabaseError as e:
-                    raise
-                conn.commit()
-                pending.clear()
-def fetch_all_pages_for_query(
-    session: Session,
-    query: str,
-    count: int,
-    rows_per_page: int,
-    timeout_seconds: float,
-    retries: int,
-    fields: Sequence[str],
-    rows_out: "queue.Queue[Optional[List[Tuple]]]",
-    items_bar: tqdm,
-    pages_bar: tqdm,
-) -> None:
-    for page in enumerate_pages(count, rows_per_page):
-        try:
-            docs = fetch_page_docs(session, query, page, rows_per_page, timeout_seconds, retries, fields)
-        except requests.exceptions.RequestException as e:
-            # Skip this page; keep going
-            continue
-        except json.JSONDecodeError as e:
-            continue
-        rows = docs_to_rows(docs)
-        if rows:
-            rows_out.put(rows)
-        items_bar.update(len(docs))
-        pages_bar.update(1)
-def run() -> None:
-    # Configuration (no globals)
-    database_path = "archive.org.db"
-    # start_date = dt.date(1600, 1, 1)
-    # end_date = dt.date(1949, 12, 31)
-    start_date = dt.date(1880, 1, 1)
-    end_date = dt.date(1881, 12, 31)
-    rows_per_page = 1000
-    request_timeout_seconds = 5.0
-    request_retries = 2
-    writer_commit_batch_size = 500
-    fields = ["creator", "date", "downloads", "identifier", "item_size", "subject", "title"]
-    session = requests.Session()
-    # Plan queries by date with progress
-    planned: List[Tuple[str, int]] = []
-    with tqdm(desc="building recursive queries", total=None, unit=" queries") as plan_bar:
-        for m_start, m_end in month_ranges(start_date, end_date):
-            _plan_queries_recursive(session, m_start, m_end, planned, request_timeout_seconds, request_retries)
-            plan_bar.update(1)
-    total_docs_planned = sum(max(0, c) for _, c in planned)
-    total_pages_planned = sum(len(enumerate_pages(c, rows_per_page)) for _, c in planned)
-    rows_queue: "queue.Queue[Optional[List[Tuple]]]" = queue.Queue(maxsize=128)
-    writer_thread = threading.Thread(
-        target=writer_loop,
-        args=(database_path, rows_queue, writer_commit_batch_size),
-        daemon=True,
-    )
-    writer_thread.start()
-    # Parallel fetch using threads from tqdm via map with chunks
-    # Use per-query parallelism to avoid oversubscribing
-    max_workers = 2
-    with tqdm(total=total_docs_planned, desc="items", unit="items") as items_bar, \
-         tqdm(total=total_pages_planned, desc="pages", unit="pages") as pages_bar, \
-         ThreadPoolExecutor(max_workers=max_workers) as pool:
-        futures = []
-        for query, count in planned:
-            if count <= 0:
-                continue
-            futures.append(
-                pool.submit(
-                    fetch_all_pages_for_query,
-                    session, query, count, rows_per_page,
-                    request_timeout_seconds, request_retries,
-                    fields, rows_queue,
-                    items_bar, pages_bar,
-                )
-            )
-        for f in as_completed(futures):
-            try:
-                f.result()
-            except Exception as e:
-                # Fail fast on unexpected exceptions
-                raise
-    rows_queue.put(None)
-    writer_thread.join()
-if __name__ == "__main__":
-    run()