medsci-skills 5.0.0 → 5.2.0

package/skills/fulltext-retrieval/fetch_oa.py

@@ -2,20 +2,28 @@
 """
 Open-access full-text PDF batch retrieval.
 
-Pipeline: Unpaywall → PMC (Europe PMC REST / OA FTP / web) →
-          OpenAlex → Crossref → landing-page scrape.
+Pipeline: arXiv (for 10.48550/arXiv.* DOIs) → Unpaywall →
+          PMC (Europe PMC REST / OA FTP / web) → OpenAlex → Crossref →
+          landing-page scrape.
 
 Usage:
     python fetch_oa.py dois.txt --output pdfs/ --email user@example.com
-    python fetch_oa.py dois.txt -o pdfs/ -e user@example.com --verbose
+    python fetch_oa.py worklist.tsv -o pdfs/ -e user@example.com --verbose
+    python fetch_oa.py worklist.csv -o pdfs/ -e user@example.com --report pdfs/retrieval_report.json
+
+Worklist formats: plain DOI-per-line, or TSV/CSV/Markdown-table with a DOI
+column (optional PMID and Title columns). A Title column enables a best-effort
+title cross-check (via `pdftotext` if installed) that flags mislabeled PDFs.
 """
 
 import argparse
+import csv
+import io
 import json
 import logging
-import os
 import re
-import sys
+import shutil
+import subprocess
 import time
 import urllib.error
 import urllib.parse
@@ -25,6 +33,9 @@ from pathlib import Path
 
 MIN_PDF_BYTES = 10 * 1024
 USER_AGENT = "medsci-skills/1.0"
+REPORT_SCHEMA_VERSION = 1
+TITLE_MATCH_THRESHOLD = 0.6
+RETRIEVED_STATUSES = ("oa", "pmc", "arxiv", "skip")
 
 log = logging.getLogger("fetch_oa")
 
@@ -38,6 +49,11 @@ def _ua(email: str) -> str:
     return f"{USER_AGENT} (mailto:{email})"
 
 
+def safe_doi_name(doi: str) -> str:
+    """Filesystem-safe filename stem for a DOI."""
+    return re.sub(r"[^\w\-.]", "_", doi)
+
+
 def is_valid_pdf(data: bytes) -> bool:
     return data.startswith(b"%PDF-") and len(data) >= MIN_PDF_BYTES
 
@@ -68,6 +84,84 @@ def existing_pdf_ok(path: Path) -> bool:
         return False
 
 
+# ============================================================
+# Title cross-check (pure, offline-testable)
+# ============================================================
+
+def normalize_title(text: str) -> str:
+    """Lowercase, strip punctuation, collapse whitespace."""
+    text = (text or "").lower()
+    text = re.sub(r"[^a-z0-9\s]", " ", text)
+    return " ".join(text.split())
+
+
+def title_overlap(expected_title: str, extracted_text: str) -> float:
+    """Fraction of meaningful expected-title tokens present in extracted text.
+
+    Tokens of length <= 2 are dropped as near-stopwords. Returns 0.0 when the
+    expected title has no usable tokens.
+    """
+    expected = {t for t in normalize_title(expected_title).split() if len(t) > 2}
+    if not expected:
+        return 0.0
+    got = set(normalize_title(extracted_text).split())
+    return len(expected & got) / len(expected)
+
+
+def classify_title_match(expected_title: str, extracted_text,
+                         threshold: float = TITLE_MATCH_THRESHOLD) -> str:
+    """Tri-state title check: 'match' | 'mismatch' | 'unavailable'.
+
+    'unavailable' when no expected title is supplied or no extracted text is
+    available (e.g. pdftotext absent). A low overlap is 'mismatch' — flagged,
+    never used to auto-reject a downloaded PDF.
+    """
+    if not expected_title or not extracted_text:
+        return "unavailable"
+    return "match" if title_overlap(expected_title, extracted_text) >= threshold else "mismatch"
+
+
+def extract_pdf_text(path: Path, max_pages: int = 2) -> str | None:
+    """Best-effort first-page text via `pdftotext` (poppler). None if unavailable."""
+    if not shutil.which("pdftotext"):
+        return None
+    try:
+        out = subprocess.run(
+            ["pdftotext", "-f", "1", "-l", str(max_pages), str(path), "-"],
+            capture_output=True, timeout=20,
+        )
+        if out.returncode == 0:
+            return out.stdout.decode("utf-8", errors="ignore")
+    except (OSError, subprocess.SubprocessError):
+        pass
+    return None
+
+
+# ============================================================
+# arXiv (direct, for 10.48550/arXiv.* DOIs)
+# ============================================================
+
+_ARXIV_DOI_RE = re.compile(r"^10\.48550/arxiv\.(.+)$", re.IGNORECASE)
+_ARXIV_ID_RE = re.compile(r"^arxiv:(.+)$", re.IGNORECASE)
+
+
+def arxiv_id_from_doi(doi: str) -> str | None:
+    """Extract an arXiv ID from a DataCite arXiv DOI or a bare arXiv: id.
+
+    Handles new-style (2401.01234, 2401.01234v2) and old-style
+    (hep-th/9901001) identifiers; version suffix preserved when present.
+    """
+    s = (doi or "").strip()
+    m = _ARXIV_DOI_RE.match(s) or _ARXIV_ID_RE.match(s)
+    return m.group(1).strip() if m else None
+
+
+def arxiv_pdf_url(doi: str) -> str | None:
+    """Direct arXiv PDF URL for an arXiv DOI/ID (None if not an arXiv id)."""
+    aid = arxiv_id_from_doi(doi)
+    return f"https://arxiv.org/pdf/{aid}" if aid else None
+
+
 # ============================================================
 # 1. Unpaywall
 # ============================================================
@@ -270,41 +364,34 @@ def download_pdf(url: str, outpath: Path, email: str) -> bool:
 # 5. Main pipeline
 # ============================================================
 
-def gather_candidates(doi: str, email: str) -> list[str]:
-    """Collect OA PDF candidate URLs from multiple sources."""
-    urls: list[str] = []
-
-    def add(v: str | None):
-        if v and v not in urls:
-            urls.append(v)
-
-    add(unpaywall_lookup(doi, email))
-    for v in openalex_lookup(doi, email):
-        add(v)
-    for v in crossref_lookup(doi, email):
-        add(v)
-    add(f"https://doi.org/{doi}")
-    return urls
-
-
 def process_doi(doi: str, outdir: Path, email: str,
-                pmid: str = "") -> str:
-    """Try to download a PDF for one DOI. Returns status string."""
-    safe_name = re.sub(r"[^\w\-.]", "_", doi)
-    outpath = outdir / f"{safe_name}.pdf"
+                pmid: str = "") -> tuple[str, str]:
+    """Try to download a PDF for one DOI.
+
+    Returns (status, source):
+      status ∈ {"arxiv", "oa", "pmc", "skip", "fail"}
+      source identifies the resolver that succeeded (e.g. "unpaywall", "pmc",
+      "openalex", "crossref", "landing", "arxiv", "existing", "").
+    """
+    outpath = outdir / f"{safe_doi_name(doi)}.pdf"
 
     if existing_pdf_ok(outpath):
-        return "skip"
+        return ("skip", "existing")
 
     # Remove stale stub
     if outpath.exists():
         outpath.unlink(missing_ok=True)
 
+    # Step 0: arXiv direct (for 10.48550/arXiv.* DOIs)
+    ax_url = arxiv_pdf_url(doi)
+    if ax_url and download_pdf(ax_url, outpath, email):
+        return ("arxiv", "arxiv")
+
     # Step 1: Unpaywall direct PDF URL (fastest path)
     uw_url = unpaywall_lookup(doi, email)
     if uw_url and ".pdf" in uw_url.lower():
         if download_pdf(uw_url, outpath, email):
-            return "oa"
+            return ("oa", "unpaywall")
         time.sleep(0.3)
 
     # Step 2: PMC (try before slow landing-page scraping)
@@ -312,59 +399,158 @@ def process_doi(doi: str, outdir: Path, email: str,
     if not pmcid:
         pmcid = id_to_pmcid(doi, email)
     if pmcid and download_pmc_pdf(pmcid, outpath, email):
-        return "pmc"
+        return ("pmc", "pmc")
 
     # Step 3: OA candidates from OpenAlex, Crossref, landing pages
-    candidates: list[str] = []
-    if uw_url and uw_url not in candidates:
-        candidates.append(uw_url)
+    candidates: list[tuple[str, str]] = []
+    seen: set[str] = set()
+
+    def add(source: str, url: str | None):
+        if url and url not in seen:
+            seen.add(url)
+            candidates.append((source, url))
+
+    add("unpaywall", uw_url)
     for v in openalex_lookup(doi, email):
-        if v not in candidates:
-            candidates.append(v)
+        add("openalex", v)
     for v in crossref_lookup(doi, email):
-        if v not in candidates:
-            candidates.append(v)
-    candidates.append(f"https://doi.org/{doi}")
+        add("crossref", v)
+    add("landing", f"https://doi.org/{doi}")
 
-    for url in candidates:
+    for source, url in candidates:
         if ".pdf" in url.lower():
             ok = download_pdf(url, outpath, email)
         else:
             ok = download_from_landing(url, outpath, email)
         if ok:
-            return "oa"
+            return ("oa", source)
         time.sleep(0.3)
 
-    return "fail"
+    return ("fail", "")
+
+
+def build_report(records: list[dict], results: dict[str, tuple[str, str]],
+                 outdir: Path, extracted_text_by_doi: dict[str, str] | None = None,
+                 threshold: float = TITLE_MATCH_THRESHOLD) -> dict:
+    """Assemble a deterministic retrieval report (no network, no I/O writes).
+
+    records: list of {"doi", "pmid", "title"}.
+    results: doi -> (status, source) as returned by process_doi.
+    outdir:  directory where PDFs were written (used for file/size lookup).
+    extracted_text_by_doi: optional doi -> first-page text for title cross-check.
+    """
+    extracted_text_by_doi = extracted_text_by_doi or {}
+    items = []
+    for rec in records:
+        doi = rec["doi"]
+        status, source = results.get(doi, ("fail", ""))
+        path = outdir / f"{safe_doi_name(doi)}.pdf"
+        have_file = status in RETRIEVED_STATUSES and path.exists()
+        size = path.stat().st_size if have_file else 0
+        if have_file:
+            title_match = classify_title_match(
+                rec.get("title", ""), extracted_text_by_doi.get(doi), threshold)
+        else:
+            title_match = "unavailable"
+        items.append({
+            "doi": doi,
+            "pmid": rec.get("pmid", ""),
+            "title": rec.get("title", ""),
+            "status": status,
+            "source": source,
+            "file": path.name if have_file else "",
+            "size_bytes": size,
+            "title_match": title_match,
+        })
+
+    retrieved = [i for i in items if i["status"] in RETRIEVED_STATUSES]
+    not_retrieved = [i for i in items if i["status"] == "fail"]
+    return {
+        "schema_version": REPORT_SCHEMA_VERSION,
+        "generated_by": "fetch_oa.py",
+        "counts": {
+            "total": len(items),
+            "retrieved": len(retrieved),
+            "not_retrieved": len(not_retrieved),
+            "title_mismatch": sum(1 for i in items if i["title_match"] == "mismatch"),
+        },
+        "items": items,
+    }
+
+
+def _norm_key(key: str) -> str:
+    return (key or "").strip().lstrip("#").strip().lower()
+
+
+def _records_from_dictrows(rows) -> list[dict]:
+    records = []
+    for row in rows:
+        rec = {"doi": "", "pmid": "", "title": ""}
+        for k, v in row.items():
+            nk = _norm_key(k)
+            if nk in rec:
+                rec[nk] = (v or "").strip()
+        if rec["doi"]:
+            records.append(rec)
+    return records
+
+
+def _records_from_markdown(lines: list[str]) -> list[dict]:
+    pipe_rows = [ln for ln in lines if ln.strip().startswith("|")]
+    if not pipe_rows:
+        return []
+
+    def cells(line: str) -> list[str]:
+        return [c.strip() for c in line.strip().strip("|").split("|")]
+
+    header = [_norm_key(c) for c in cells(pipe_rows[0])]
+    records = []
+    for line in pipe_rows[1:]:
+        c = cells(line)
+        # Skip the |---|---| separator row
+        if c and all(set(x) <= set("-: ") for x in c):
+            continue
+        row = dict(zip(header, c))
+        doi = (row.get("doi") or "").strip()
+        if doi:
+            records.append({
+                "doi": doi,
+                "pmid": (row.get("pmid") or "").strip(),
+                "title": (row.get("title") or "").strip(),
+            })
+    return records
 
 
 def read_doi_file(path: Path) -> list[dict]:
-    """Read DOI list. Supports plain DOIs or TSV with DOI/PMID columns."""
+    """Read a worklist of DOIs.
+
+    Supports: plain DOI-per-line; TSV/CSV with a DOI header (optional PMID,
+    Title columns); and a Markdown pipe table with a DOI column. Each record is
+    {"doi", "pmid", "title"}.
+    """
+    text = Path(path).read_text(encoding="utf-8")
+    lines = text.splitlines()
+    first = next((ln for ln in lines
+                  if ln.strip() and not ln.strip().startswith("#")), "")
+    low = first.lower()
+
+    # Markdown pipe table with a DOI column
+    if first.strip().startswith("|") and "doi" in low:
+        return _records_from_markdown(lines)
+
+    # Delimited (TSV or CSV) with a DOI header
+    if "doi" in low and ("\t" in first or "," in first):
+        delimiter = "\t" if "\t" in first else ","
+        body = "\n".join(ln for ln in lines if not ln.strip().startswith("#"))
+        reader = csv.DictReader(io.StringIO(body), delimiter=delimiter)
+        return _records_from_dictrows(reader)
+
+    # Plain text: one DOI per line
     records = []
-    with open(path, encoding="utf-8") as f:
-        first_line = f.readline().strip()
-        f.seek(0)
-
-        # TSV with header containing DOI column
-        if "\t" in first_line and "doi" in first_line.lower():
-            import csv
-            reader = csv.DictReader(f, delimiter="\t")
-            for row in reader:
-                doi = ""
-                pmid = ""
-                for k, v in row.items():
-                    if k.lower().strip() == "doi":
-                        doi = (v or "").strip()
-                    elif k.lower().strip() == "pmid":
-                        pmid = (v or "").strip()
-                if doi:
-                    records.append({"doi": doi, "pmid": pmid})
-        else:
-            # Plain text: one DOI per line
-            for line in f:
-                line = line.strip()
-                if line and not line.startswith("#"):
-                    records.append({"doi": line, "pmid": ""})
+    for line in lines:
+        line = line.strip()
+        if line and not line.startswith("#"):
+            records.append({"doi": line, "pmid": "", "title": ""})
     return records
 
 
@@ -372,11 +558,15 @@ def main():
     parser = argparse.ArgumentParser(
         description="Batch download open-access PDFs by DOI.")
     parser.add_argument("input", type=Path,
-                        help="File with DOIs (one per line, or TSV with DOI column)")
+                        help="Worklist: DOIs (one per line) or TSV/CSV/Markdown "
+                             "with a DOI column (optional PMID, Title)")
     parser.add_argument("-o", "--output", type=Path, default=Path("pdfs"),
                         help="Output directory (default: pdfs/)")
     parser.add_argument("-e", "--email", required=True,
                         help="Contact email (required by Unpaywall TOS)")
+    parser.add_argument("--report", type=Path, default=None,
+                        help="Path for the JSON retrieval report "
+                             "(default: <output>/retrieval_report.json)")
     parser.add_argument("-v", "--verbose", action="store_true",
                         help="Show debug messages")
     args = parser.parse_args()
@@ -387,33 +577,62 @@ def main():
     )
 
     args.output.mkdir(parents=True, exist_ok=True)
+    report_path = args.report or (args.output / "retrieval_report.json")
     records = read_doi_file(args.input)
     print(f"Loaded {len(records)} DOIs from {args.input}")
 
-    stats = {"oa": 0, "pmc": 0, "fail": 0, "skip": 0}
+    stats = {"arxiv": 0, "oa": 0, "pmc": 0, "fail": 0, "skip": 0}
+    results: dict[str, tuple[str, str]] = {}
 
     for i, rec in enumerate(records, 1):
         doi = rec["doi"]
         pmid = rec.get("pmid", "")
         print(f"  [{i}/{len(records)}] {doi}", end=" … ", flush=True)
 
-        status = process_doi(doi, args.output, args.email, pmid)
+        status, source = process_doi(doi, args.output, args.email, pmid)
+        results[doi] = (status, source)
         stats[status] += 1
 
-        labels = {"oa": "OK (OA)", "pmc": "OK (PMC)",
+        labels = {"arxiv": "OK (arXiv)", "oa": "OK (OA)", "pmc": "OK (PMC)",
                   "fail": "FAIL", "skip": "SKIP"}
         print(labels[status])
         time.sleep(0.5)
 
+    # Best-effort title cross-check on successful downloads (needs pdftotext).
+    extracted: dict[str, str] = {}
+    have_titles = any(r.get("title") for r in records)
+    if have_titles and shutil.which("pdftotext"):
+        for rec in records:
+            doi = rec["doi"]
+            if not rec.get("title"):
+                continue
+            status, _ = results.get(doi, ("fail", ""))
+            if status not in RETRIEVED_STATUSES:
+                continue
+            path = args.output / f"{safe_doi_name(doi)}.pdf"
+            if path.exists():
+                text = extract_pdf_text(path)
+                if text:
+                    extracted[doi] = text
+
+    report = build_report(records, results, args.output, extracted)
+    report_path.parent.mkdir(parents=True, exist_ok=True)
+    report_path.write_text(json.dumps(report, indent=2) + "\n", encoding="utf-8")
+
     print(f"\n--- Summary ---")
+    print(f"  arXiv:   {stats['arxiv']}")
     print(f"  OA:      {stats['oa']}")
     print(f"  PMC:     {stats['pmc']}")
     print(f"  Failed:  {stats['fail']}")
     print(f"  Skipped: {stats['skip']}")
-    total = stats["oa"] + stats["pmc"] + stats["fail"]
+    total = stats["arxiv"] + stats["oa"] + stats["pmc"] + stats["fail"]
     if total > 0:
-        pct = (stats["oa"] + stats["pmc"]) / total * 100
+        pct = (stats["arxiv"] + stats["oa"] + stats["pmc"]) / total * 100
         print(f"  Success: {pct:.0f}%")
+    mismatches = report["counts"]["title_mismatch"]
+    if mismatches:
+        print(f"  Title mismatches flagged: {mismatches} (see report)")
+    print(f"  Report:  {report_path}")
 
     # Write failed DOIs for manual retrieval
     if stats["fail"] > 0:
@@ -422,10 +641,10 @@ def main():
             f.write("# DOIs needing manual retrieval\n")
             f.write("# Options: institutional access, ILL\n\n")
             for rec in records:
-                safe = re.sub(r"[^\w\-.]", "_", rec["doi"])
-                pdf = args.output / f"{safe}.pdf"
+                doi = rec["doi"]
+                pdf = args.output / f"{safe_doi_name(doi)}.pdf"
                 if not existing_pdf_ok(pdf):
-                    f.write(f"{rec['doi']}\n")
+                    f.write(f"{doi}\n")
         print(f"  Manual list: {fail_path}")
 
 

package/skills/fulltext-retrieval/fetch_oa_report_challenge/expected/projection.json

@@ -0,0 +1,14 @@
+{
+  "counts": {
+    "total": 4,
+    "retrieved": 3,
+    "not_retrieved": 1,
+    "title_mismatch": 1
+  },
+  "items": [
+    {"doi": "10.1111/valid.match", "status": "oa", "source": "unpaywall", "title_match": "match"},
+    {"doi": "10.2222/label.mismatch", "status": "oa", "source": "openalex", "title_match": "mismatch"},
+    {"doi": "10.3333/no.text", "status": "pmc", "source": "pmc", "title_match": "unavailable"},
+    {"doi": "10.9999/not.retrieved", "status": "fail", "source": "", "title_match": "unavailable"}
+  ]
+}

package/skills/fulltext-retrieval/fetch_oa_report_challenge/extracted_text.json

@@ -0,0 +1,4 @@
+{
+  "10.1111/valid.match": "Deep Learning for Pulmonary Nodule Detection on Chest CT\nAbstract: we present a convolutional neural network trained to detect pulmonary nodules.",
+  "10.2222/label.mismatch": "Genome-wide association study of type 2 diabetes in an Asian cohort\nIntroduction: we genotyped participants to identify susceptibility loci."
+}

package/skills/fulltext-retrieval/fetch_oa_report_challenge/results.json

@@ -0,0 +1,6 @@
+{
+  "10.1111/valid.match": ["oa", "unpaywall"],
+  "10.2222/label.mismatch": ["oa", "openalex"],
+  "10.3333/no.text": ["pmc", "pmc"],
+  "10.9999/not.retrieved": ["fail", ""]
+}

package/skills/fulltext-retrieval/fetch_oa_report_challenge/run_challenge.py

@@ -0,0 +1,86 @@
+#!/usr/bin/env python3
+"""Offline, network-free challenge for fetch_oa.build_report + title tri-state.
+
+Loads committed fixtures (worklist.tsv, results.json, extracted_text.json),
+fabricates stub PDFs in a temp dir for the "retrieved" DOIs, runs
+fetch_oa.build_report, and asserts the resulting projection equals
+expected/projection.json. Exercises read_doi_file (TSV+title), build_report,
+and classify_title_match (match / mismatch / unavailable) without touching the
+network or pdftotext. Stdlib-only.
+"""
+import importlib.util
+import json
+import sys
+import tempfile
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+ENGINE = HERE.parent / "fetch_oa.py"
+
+
+def load_engine():
+    spec = importlib.util.spec_from_file_location("fetch_oa", ENGINE)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+def projection(report: dict) -> dict:
+    items = sorted(
+        ({"doi": i["doi"], "status": i["status"], "source": i["source"],
+          "title_match": i["title_match"]} for i in report["items"]),
+        key=lambda x: x["doi"],
+    )
+    return {"counts": report["counts"], "items": items}
+
+
+def main() -> int:
+    assert ENGINE.exists(), f"ENV-ERR: {ENGINE} missing"
+    m = load_engine()
+
+    records = m.read_doi_file(HERE / "worklist.tsv")
+    results = {k: tuple(v) for k, v in
+               json.loads((HERE / "results.json").read_text()).items()}
+    extracted = json.loads((HERE / "extracted_text.json").read_text())
+    expected = json.loads((HERE / "expected" / "projection.json").read_text())
+
+    fails = []
+
+    def check(label, cond):
+        print(f"  {'PASS' if cond else 'FAIL'}  {label}")
+        if not cond:
+            fails.append(label)
+
+    with tempfile.TemporaryDirectory() as tmp:
+        outdir = Path(tmp)
+        for rec in records:
+            status, _ = results.get(rec["doi"], ("fail", ""))
+            if status in m.RETRIEVED_STATUSES:
+                stub = outdir / f"{m.safe_doi_name(rec['doi'])}.pdf"
+                stub.write_bytes(b"%PDF-1.4\n" + b"0" * (11 * 1024))
+        report = m.build_report(records, results, outdir, extracted)
+        proj = projection(report)
+
+    by_doi = {i["doi"]: i for i in proj["items"]}
+    check("valid -> title_match 'match'",
+          by_doi["10.1111/valid.match"]["title_match"] == "match")
+    check("mislabel -> title_match 'mismatch'",
+          by_doi["10.2222/label.mismatch"]["title_match"] == "mismatch")
+    check("no-text -> title_match 'unavailable'",
+          by_doi["10.3333/no.text"]["title_match"] == "unavailable")
+    check("missing -> status 'fail'",
+          by_doi["10.9999/not.retrieved"]["status"] == "fail")
+    check("counts.retrieved == 3", proj["counts"]["retrieved"] == 3)
+    check("counts.not_retrieved == 1", proj["counts"]["not_retrieved"] == 1)
+    check("counts.title_mismatch == 1", proj["counts"]["title_mismatch"] == 1)
+    check("projection matches expected/projection.json", proj == expected)
+
+    if fails:
+        print(f"FAILURES: {len(fails)}")
+        return 1
+    print("ALL PASS")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/skills/fulltext-retrieval/fetch_oa_report_challenge/verify.sh

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+# Network-free challenge: fetch_oa report builder + title-match tri-state.
+# Mirrors CI usage: `bash skills/fulltext-retrieval/fetch_oa_report_challenge/verify.sh`
+set -euo pipefail
+DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+python3 "$DIR/run_challenge.py"

package/skills/fulltext-retrieval/fetch_oa_report_challenge/worklist.tsv

@@ -0,0 +1,5 @@
+DOI	PMID	Title
+10.1111/valid.match	1001	Deep learning for pulmonary nodule detection on chest CT
+10.2222/label.mismatch	1002	Automated segmentation of cardiac MRI using transformers
+10.3333/no.text	1003	Federated learning for multi-center radiology models
+10.9999/not.retrieved	1004	A paywalled study with no open-access copy