Upload folder using huggingface_hub

scripts/aacl/aacl.py

@@ -0,0 +1,130 @@
+import json
+import requests
+from bs4 import BeautifulSoup
+
+SOURCE_URL = "https://aclanthology.org/events/aacl-{year}/"
+OUTPUT_FILE = "data/aacl/aacl{year}_papers.jsonl"
+BASE_URL = "https://aclanthology.org"
+
+
+def fetch_page(url):
+    headers = {"User-Agent": "Mozilla/5.0 (ACL-parser/1.0; research)"}
+    print(f"Fetching {url} ...", flush=True)
+    resp = requests.get(url, headers=headers, timeout=120)
+    resp.raise_for_status()
+    # with open("acl.txt", "w") as f:
+    #     f.write(resp.text)
+    return resp.text
+
+
+def abs_url(href):
+    if not href:
+        return ""
+    return href if href.startswith("http") else BASE_URL + href
+
+
+def parse_papers(html):
+    soup = BeautifulSoup(html, "html.parser")
+    papers = []
+    
+    # Find all paper divs - each paper is in a div with class "d-sm-flex align-items-stretch mb-3"
+    paper_divs = soup.find_all("div", class_="d-sm-flex align-items-stretch mb-3")
+    
+    for paper_div in paper_divs:
+        paper = parse_paper_div(paper_div)
+        if paper:
+            papers.append(paper)
+    
+    return papers
+
+
+def parse_paper_div(paper_div):
+    # Extract the paper title and URL
+    title_element = paper_div.find("strong")
+    if not title_element:
+        return None
+    
+    title_link = title_element.find("a")
+    if not title_link:
+        return None
+    
+    title = title_link.get_text(strip=False)
+    href = title_link.get("href", "")
+    paper_id = href.strip("/").split("/")[-1] if href else ""
+    url = abs_url(href)
+    
+    # Skip if no paper_id found
+    if not paper_id:
+        return None
+    
+    # PDF / BIB links from the button-row div
+    pdf_url = bib_url = ""
+    btn_row = paper_div.find("div", class_="list-button-row")
+    if btn_row:
+        for a in btn_row.find_all("a", href=True):
+            text = a.get_text(strip=True).lower()
+            h = a["href"]
+            if text == "pdf" or h.endswith(".pdf"):
+                pdf_url = abs_url(h)
+            elif text == "bib" or h.endswith(".bib"):
+                bib_url = abs_url(h)
+    
+    # Authors: <a href="/people/..."> links inside the d-block span
+    authors = []
+    span = paper_div.find("span", class_="d-block")
+    if span:
+        for a in span.find_all("a", href=True):
+            if "/people/" in a["href"]:
+                authors.append(a.get_text(strip=True))
+    
+    # Abstract: look for the collapse div with abstract content
+    abstract = ""
+    # Find the abstract ID from the button
+    abs_button = paper_div.find("a", class_="badge text-bg-info")
+    if abs_button and "data-bs-target" in abs_button.attrs:
+        abs_id = abs_button["data-bs-target"].lstrip("#")
+        # Find the abstract div using this ID
+        abs_div = soup.find("div", id=abs_id)
+        if abs_div:
+            body = abs_div.find("div", class_="card-body")
+            if body:
+                abstract = body.get_text(strip=True)
+    
+    # Determine volume from paper_id
+    volume = ""
+    if paper_id:
+        parts = paper_id.split(".")
+        if len(parts) >= 2:
+            volume = parts[1]  # e.g., "acl-long" from "2023.acl-long.19"
+    
+    return {
+        "paper_id": paper_id,
+        "title": title,
+        "authors": authors,
+        "abstract": abstract,
+        "url": url,
+        "pdf_url": pdf_url,
+        "bib_url": bib_url,
+    }
+
+
+def main():
+    for year in [20, 22, 23]:
+        year = f"20{year:02d}"
+        try:
+            html = fetch_page(SOURCE_URL.format(year=year))
+            print("Parsing ...", flush=True)
+            papers = parse_papers(html)
+            
+            print(f"Found {len(papers)} papers. Writing to {OUTPUT_FILE.format(year=year)} ...", flush=True)
+            with open(OUTPUT_FILE.format(year=year), "w", encoding="utf-8") as f:
+                for p in papers:
+                    f.write(json.dumps(p, ensure_ascii=False) + "\n")
+            
+            print("Done")
+        except Exception as e:
+            print(f"Error: {e}")
+
+
+if __name__ == "__main__":
+    main()

scripts/aacl/aacl2025.py

@@ -0,0 +1,122 @@
+import json
+import requests
+from bs4 import BeautifulSoup
+
+SOURCE_URL = "https://aclanthology.org/events/aacl-2025/"
+OUTPUT_FILE = "data/aacl/aacl2025_papers.jsonl"
+BASE_URL    = "https://aclanthology.org"
+
+
+def fetch_page(url):
+    headers = {"User-Agent": "Mozilla/5.0 (ACL-parser/1.0; research)"}
+    print(f"Fetching {url} ...", flush=True)
+    resp = requests.get(url, headers=headers, timeout=120)
+    resp.raise_for_status()
+    return resp.text
+
+
+def abs_url(href):
+    if not href:
+        return ""
+    return href if href.startswith("http") else BASE_URL + href
+
+
+def parse_papers(html):
+    soup = BeautifulSoup(html, "html.parser")
+    papers = []
+
+    # Each volume section is wrapped in <div id="2025acl-long"> etc.
+    volume_divs = soup.find_all("div", id=lambda i: i and i.startswith("2025"))
+
+    for vol_div in volume_divs:
+        volume_id = vol_div.get("id", "")
+
+        # Volume name is in the <a class="align-middle"> inside the <h4>
+        h4 = vol_div.find("h4")
+        if h4:
+            vol_link = h4.find("a", class_="align-middle")
+            volume_name = vol_link.get_text(strip=True) if vol_link else h4.get_text(strip=True)
+        else:
+            volume_name = volume_id
+
+        # Each paper is a <div class="d-sm-flex align-items-stretch mb-3">
+        for card in vol_div.find_all("div", class_="d-sm-flex align-items-stretch mb-3"):
+            paper = parse_card(card, volume_id, volume_name)
+            if paper:
+                papers.append(paper)
+
+    return papers
+
+
+def parse_card(card, volume_id, volume_name):
+    # Title
+    strong = card.find("strong")
+    if not strong:
+        return None
+    title_link = strong.find("a")
+    if not title_link:
+        return None
+
+    title = title_link.get_text(strip=False)
+    href = title_link.get("href", "")
+    paper_id = href.strip("/")
+    url = abs_url(href)
+
+    # Skip front-matter entries (end with ".0")
+    if paper_id.endswith(".0"):
+        return None
+
+    # PDF / BIB from the button-row div
+    pdf_url = bib_url = ""
+    btn_row = card.find("div", class_="list-button-row")
+    if btn_row:
+        for a in btn_row.find_all("a", href=True):
+            text = a.get_text(strip=True).lower()
+            h    = a["href"]
+            if text == "pdf" or h.endswith(".pdf"):
+                pdf_url = abs_url(h)
+            elif text == "bib" or h.endswith(".bib"):
+                bib_url = abs_url(h)
+
+    # Authors: <a href="/people/..."> links inside the d-block span
+    authors = []
+    span = card.find("span", class_="d-block")
+    if span:
+        for a in span.find_all("a", href=True):
+            if "/people/" in a["href"]:
+                authors.append(a.get_text(strip=True))
+
+    # Abstract: next sibling div with class "abstract-collapse"
+    abstract = ""
+    nxt = card.find_next_sibling()
+    if nxt and "abstract-collapse" in nxt.get("class", []):
+        body = nxt.find("div", class_="card-body")
+        if body:
+            abstract = body.get_text(strip=True)
+
+    return {
+        "paper_id":  paper_id,
+        "title":     title,
+        "authors":   authors,
+        "abstract":  abstract,
+        "url":       url,
+        "pdf_url":   pdf_url,
+        "bib_url":   bib_url,
+    }
+
+
+def main():
+    html = fetch_page(SOURCE_URL)
+    print("Parsing ...", flush=True)
+    papers = parse_papers(html)
+
+    print(f"Found {len(papers)} papers. Writing to {OUTPUT_FILE} ...", flush=True)
+    with open(OUTPUT_FILE, "w", encoding="utf-8") as f:
+        for p in papers:
+            f.write(json.dumps(p, ensure_ascii=False) + "\n")
+
+    print("Done")
+
+
+if __name__ == "__main__":
+    main()

scripts/acl/acl.py

@@ -0,0 +1,130 @@
+import json
+import requests
+from bs4 import BeautifulSoup
+
+SOURCE_URL = "https://aclanthology.org/events/acl-{year}/"
+OUTPUT_FILE = "data/acl/acl{year}_papers.jsonl"
+BASE_URL = "https://aclanthology.org"
+
+
+def fetch_page(url):
+    headers = {"User-Agent": "Mozilla/5.0 (ACL-parser/1.0; research)"}
+    print(f"Fetching {url} ...", flush=True)
+    resp = requests.get(url, headers=headers, timeout=120)
+    resp.raise_for_status()
+    # with open("acl.txt", "w") as f:
+    #     f.write(resp.text)
+    return resp.text
+
+
+def abs_url(href):
+    if not href:
+        return ""
+    return href if href.startswith("http") else BASE_URL + href
+
+
+def parse_papers(html):
+    soup = BeautifulSoup(html, "html.parser")
+    papers = []
+    
+    # Find all paper divs - each paper is in a div with class "d-sm-flex align-items-stretch mb-3"
+    paper_divs = soup.find_all("div", class_="d-sm-flex align-items-stretch mb-3")
+    
+    for paper_div in paper_divs:
+        paper = parse_paper_div(paper_div)
+        if paper:
+            papers.append(paper)
+    
+    return papers
+
+
+def parse_paper_div(paper_div):
+    # Extract the paper title and URL
+    title_element = paper_div.find("strong")
+    if not title_element:
+        return None
+    
+    title_link = title_element.find("a")
+    if not title_link:
+        return None
+    
+    title = title_link.get_text(strip=False)
+    href = title_link.get("href", "")
+    paper_id = href.strip("/").split("/")[-1] if href else ""
+    url = abs_url(href)
+    
+    # Skip if no paper_id found
+    if not paper_id:
+        return None
+    
+    # PDF / BIB links from the button-row div
+    pdf_url = bib_url = ""
+    btn_row = paper_div.find("div", class_="list-button-row")
+    if btn_row:
+        for a in btn_row.find_all("a", href=True):
+            text = a.get_text(strip=True).lower()
+            h = a["href"]
+            if text == "pdf" or h.endswith(".pdf"):
+                pdf_url = abs_url(h)
+            elif text == "bib" or h.endswith(".bib"):
+                bib_url = abs_url(h)
+    
+    # Authors: <a href="/people/..."> links inside the d-block span
+    authors = []
+    span = paper_div.find("span", class_="d-block")
+    if span:
+        for a in span.find_all("a", href=True):
+            if "/people/" in a["href"]:
+                authors.append(a.get_text(strip=True))
+    
+    # Abstract: look for the collapse div with abstract content
+    abstract = ""
+    # Find the abstract ID from the button
+    abs_button = paper_div.find("a", class_="badge text-bg-info")
+    if abs_button and "data-bs-target" in abs_button.attrs:
+        abs_id = abs_button["data-bs-target"].lstrip("#")
+        # Find the abstract div using this ID
+        abs_div = soup.find("div", id=abs_id)
+        if abs_div:
+            body = abs_div.find("div", class_="card-body")
+            if body:
+                abstract = body.get_text(strip=True)
+    
+    # Determine volume from paper_id
+    volume = ""
+    if paper_id:
+        parts = paper_id.split(".")
+        if len(parts) >= 2:
+            volume = parts[1]  # e.g., "acl-long" from "2023.acl-long.19"
+    
+    return {
+        "paper_id": paper_id,
+        "title": title,
+        "authors": authors,
+        "abstract": abstract,
+        "url": url,
+        "pdf_url": pdf_url,
+        "bib_url": bib_url,
+    }
+
+
+def main():
+    for year in range(25):
+        year = f"20{year:02d}"
+        try:
+            html = fetch_page(SOURCE_URL.format(year=year))
+            print("Parsing ...", flush=True)
+            papers = parse_papers(html)
+            
+            print(f"Found {len(papers)} papers. Writing to {OUTPUT_FILE.format(year=year)} ...", flush=True)
+            with open(OUTPUT_FILE.format(year=year), "w", encoding="utf-8") as f:
+                for p in papers:
+                    f.write(json.dumps(p, ensure_ascii=False) + "\n")
+            
+            print("Done")
+        except Exception as e:
+            print(f"Error: {e}")
+
+
+if __name__ == "__main__":
+    main()

scripts/acl/acl2025.py

@@ -0,0 +1,124 @@
+import json
+import requests
+from bs4 import BeautifulSoup
+
+SOURCE_URL = "https://aclanthology.org/events/acl-2025/"
+OUTPUT_FILE = "data/acl/acl2025_papers.jsonl"
+BASE_URL    = "https://aclanthology.org"
+
+
+def fetch_page(url):
+    headers = {"User-Agent": "Mozilla/5.0 (ACL-parser/1.0; research)"}
+    print(f"Fetching {url} ...", flush=True)
+    resp = requests.get(url, headers=headers, timeout=120)
+    resp.raise_for_status()
+    with open("acl.txt", "w") as f:
+        f.write(resp.text)
+    return resp.text
+
+
+def abs_url(href):
+    if not href:
+        return ""
+    return href if href.startswith("http") else BASE_URL + href
+
+
+def parse_papers(html):
+    soup = BeautifulSoup(html, "html.parser")
+    papers = []
+
+    # Each volume section is wrapped in <div id="2025acl-long"> etc.
+    volume_divs = soup.find_all("div", id=lambda i: i and i.startswith("2025"))
+
+    for vol_div in volume_divs:
+        volume_id = vol_div.get("id", "")
+
+        # Volume name is in the <a class="align-middle"> inside the <h4>
+        h4 = vol_div.find("h4")
+        if h4:
+            vol_link = h4.find("a", class_="align-middle")
+            volume_name = vol_link.get_text(strip=True) if vol_link else h4.get_text(strip=True)
+        else:
+            volume_name = volume_id
+
+        # Each paper is a <div class="d-sm-flex align-items-stretch mb-3">
+        for card in vol_div.find_all("div", class_="d-sm-flex align-items-stretch mb-3"):
+            paper = parse_card(card, volume_id, volume_name)
+            if paper:
+                papers.append(paper)
+
+    return papers
+
+
+def parse_card(card, volume_id, volume_name):
+    # Title
+    strong = card.find("strong")
+    if not strong:
+        return None
+    title_link = strong.find("a")
+    if not title_link:
+        return None
+
+    title = title_link.get_text(strip=False)
+    href = title_link.get("href", "")
+    paper_id = href.strip("/")
+    url = abs_url(href)
+
+    # Skip front-matter entries (end with ".0")
+    if paper_id.endswith(".0"):
+        return None
+
+    # PDF / BIB from the button-row div
+    pdf_url = bib_url = ""
+    btn_row = card.find("div", class_="list-button-row")
+    if btn_row:
+        for a in btn_row.find_all("a", href=True):
+            text = a.get_text(strip=True).lower()
+            h    = a["href"]
+            if text == "pdf" or h.endswith(".pdf"):
+                pdf_url = abs_url(h)
+            elif text == "bib" or h.endswith(".bib"):
+                bib_url = abs_url(h)
+
+    # Authors: <a href="/people/..."> links inside the d-block span
+    authors = []
+    span = card.find("span", class_="d-block")
+    if span:
+        for a in span.find_all("a", href=True):
+            if "/people/" in a["href"]:
+                authors.append(a.get_text(strip=True))
+
+    # Abstract: next sibling div with class "abstract-collapse"
+    abstract = ""
+    nxt = card.find_next_sibling()
+    if nxt and "abstract-collapse" in nxt.get("class", []):
+        body = nxt.find("div", class_="card-body")
+        if body:
+            abstract = body.get_text(strip=True)
+
+    return {
+        "paper_id":  paper_id,
+        "title":     title,
+        "authors":   authors,
+        "abstract":  abstract,
+        "url":       url,
+        "pdf_url":   pdf_url,
+        "bib_url":   bib_url,
+    }
+
+
+def main():
+    html = fetch_page(SOURCE_URL)
+    print("Parsing ...", flush=True)
+    papers = parse_papers(html)
+
+    print(f"Found {len(papers)} papers. Writing to {OUTPUT_FILE} ...", flush=True)
+    with open(OUTPUT_FILE, "w", encoding="utf-8") as f:
+        for p in papers:
+            f.write(json.dumps(p, ensure_ascii=False) + "\n")
+
+    print("Done")
+
+
+if __name__ == "__main__":
+    main()

scripts/cl/cl.py

@@ -0,0 +1,128 @@
+import json
+import requests
+from bs4 import BeautifulSoup
+
+SOURCE_URL = "https://aclanthology.org/events/cl-{year}/"
+OUTPUT_FILE = "data/cl/cl{year}_papers.jsonl"
+BASE_URL = "https://aclanthology.org"
+
+
+def fetch_page(url):
+    headers = {"User-Agent": "Mozilla/5.0 (ACL-parser/1.0; research)"}
+    print(f"Fetching {url} ...", flush=True)
+    resp = requests.get(url, headers=headers, timeout=120)
+    resp.raise_for_status()
+    return resp.text
+
+
+def abs_url(href):
+    if not href:
+        return ""
+    return href if href.startswith("http") else BASE_URL + href
+
+
+def parse_papers(html):
+    soup = BeautifulSoup(html, "html.parser")
+    papers = []
+    
+    # Find all paper divs - each paper is in a div with class "d-sm-flex align-items-stretch mb-3"
+    paper_divs = soup.find_all("div", class_="d-sm-flex align-items-stretch mb-3")
+    
+    for paper_div in paper_divs:
+        paper = parse_paper_div(paper_div)
+        if paper:
+            papers.append(paper)
+    
+    return papers
+
+
+def parse_paper_div(paper_div):
+    # Extract the paper title and URL
+    title_element = paper_div.find("strong")
+    if not title_element:
+        return None
+    
+    title_link = title_element.find("a")
+    if not title_link:
+        return None
+    
+    title = title_link.get_text(strip=False)
+    href = title_link.get("href", "")
+    paper_id = href.strip("/").split("/")[-1] if href else ""
+    url = abs_url(href)
+    
+    # Skip if no paper_id found
+    if not paper_id:
+        return None
+    
+    # PDF / BIB links from the button-row div
+    pdf_url = bib_url = ""
+    btn_row = paper_div.find("div", class_="list-button-row")
+    if btn_row:
+        for a in btn_row.find_all("a", href=True):
+            text = a.get_text(strip=True).lower()
+            h = a["href"]
+            if text == "pdf" or h.endswith(".pdf"):
+                pdf_url = abs_url(h)
+            elif text == "bib" or h.endswith(".bib"):
+                bib_url = abs_url(h)
+    
+    # Authors: <a href="/people/..."> links inside the d-block span
+    authors = []
+    span = paper_div.find("span", class_="d-block")
+    if span:
+        for a in span.find_all("a", href=True):
+            if "/people/" in a["href"]:
+                authors.append(a.get_text(strip=True))
+    
+    # Abstract: look for the collapse div with abstract content
+    abstract = ""
+    # Find the abstract ID from the button
+    abs_button = paper_div.find("a", class_="badge text-bg-info")
+    if abs_button and "data-bs-target" in abs_button.attrs:
+        abs_id = abs_button["data-bs-target"].lstrip("#")
+        # Find the abstract div using this ID
+        abs_div = soup.find("div", id=abs_id)
+        if abs_div:
+            body = abs_div.find("div", class_="card-body")
+            if body:
+                abstract = body.get_text(strip=True)
+    
+    # Determine volume from paper_id
+    volume = ""
+    if paper_id:
+        parts = paper_id.split(".")
+        if len(parts) >= 2:
+            volume = parts[1]  # e.g., "acl-long" from "2023.acl-long.19"
+    
+    return {
+        "paper_id": paper_id,
+        "title": title,
+        "authors": authors,
+        "abstract": abstract,
+        "url": url,
+        "pdf_url": pdf_url,
+        "bib_url": bib_url,
+    }
+
+
+def main():
+    for year in range(25):
+        year = f"20{year:02d}"
+        try:
+            html = fetch_page(SOURCE_URL.format(year=year))
+            print("Parsing ...", flush=True)
+            papers = parse_papers(html)
+            
+            print(f"Found {len(papers)} papers. Writing to {OUTPUT_FILE.format(year=year)} ...", flush=True)
+            with open(OUTPUT_FILE.format(year=year), "w", encoding="utf-8") as f:
+                for p in papers:
+                    f.write(json.dumps(p, ensure_ascii=False) + "\n")
+            
+            print("Done")
+        except Exception as e:
+            print(f"Error: {e}")
+
+
+if __name__ == "__main__":
+    main()

scripts/cl/cl2025.py

@@ -0,0 +1,122 @@
+import json
+import requests
+from bs4 import BeautifulSoup
+
+SOURCE_URL = "https://aclanthology.org/events/cl-2025/"
+OUTPUT_FILE = "data/cl/cl2025_papers.jsonl"
+BASE_URL    = "https://aclanthology.org"
+
+
+def fetch_page(url):
+    headers = {"User-Agent": "Mozilla/5.0 (ACL-parser/1.0; research)"}
+    print(f"Fetching {url} ...", flush=True)
+    resp = requests.get(url, headers=headers, timeout=120)
+    resp.raise_for_status()
+    return resp.text
+
+
+def abs_url(href):
+    if not href:
+        return ""
+    return href if href.startswith("http") else BASE_URL + href
+
+
+def parse_papers(html):
+    soup = BeautifulSoup(html, "html.parser")
+    papers = []
+
+    # Each volume section is wrapped in <div id="2025acl-long"> etc.
+    volume_divs = soup.find_all("div", id=lambda i: i and i.startswith("2025"))
+
+    for vol_div in volume_divs:
+        volume_id = vol_div.get("id", "")
+
+        # Volume name is in the <a class="align-middle"> inside the <h4>
+        h4 = vol_div.find("h4")
+        if h4:
+            vol_link = h4.find("a", class_="align-middle")
+            volume_name = vol_link.get_text(strip=True) if vol_link else h4.get_text(strip=True)
+        else:
+            volume_name = volume_id
+
+        # Each paper is a <div class="d-sm-flex align-items-stretch mb-3">
+        for card in vol_div.find_all("div", class_="d-sm-flex align-items-stretch mb-3"):
+            paper = parse_card(card, volume_id, volume_name)
+            if paper:
+                papers.append(paper)
+
+    return papers
+
+
+def parse_card(card, volume_id, volume_name):
+    # Title
+    strong = card.find("strong")
+    if not strong:
+        return None
+    title_link = strong.find("a")
+    if not title_link:
+        return None
+
+    title = title_link.get_text(strip=False)
+    href = title_link.get("href", "")
+    paper_id = href.strip("/")
+    url = abs_url(href)
+
+    # Skip front-matter entries (end with ".0")
+    if paper_id.endswith(".0"):
+        return None
+
+    # PDF / BIB from the button-row div
+    pdf_url = bib_url = ""
+    btn_row = card.find("div", class_="list-button-row")
+    if btn_row:
+        for a in btn_row.find_all("a", href=True):
+            text = a.get_text(strip=True).lower()
+            h    = a["href"]
+            if text == "pdf" or h.endswith(".pdf"):
+                pdf_url = abs_url(h)
+            elif text == "bib" or h.endswith(".bib"):
+                bib_url = abs_url(h)
+
+    # Authors: <a href="/people/..."> links inside the d-block span
+    authors = []
+    span = card.find("span", class_="d-block")
+    if span:
+        for a in span.find_all("a", href=True):
+            if "/people/" in a["href"]:
+                authors.append(a.get_text(strip=True))
+
+    # Abstract: next sibling div with class "abstract-collapse"
+    abstract = ""
+    nxt = card.find_next_sibling()
+    if nxt and "abstract-collapse" in nxt.get("class", []):
+        body = nxt.find("div", class_="card-body")
+        if body:
+            abstract = body.get_text(strip=True)
+
+    return {
+        "paper_id":  paper_id,
+        "title":     title,
+        "authors":   authors,
+        "abstract":  abstract,
+        "url":       url,
+        "pdf_url":   pdf_url,
+        "bib_url":   bib_url,
+    }
+
+
+def main():
+    html = fetch_page(SOURCE_URL)
+    print("Parsing ...", flush=True)
+    papers = parse_papers(html)
+
+    print(f"Found {len(papers)} papers. Writing to {OUTPUT_FILE} ...", flush=True)
+    with open(OUTPUT_FILE, "w", encoding="utf-8") as f:
+        for p in papers:
+            f.write(json.dumps(p, ensure_ascii=False) + "\n")
+
+    print("Done")
+
+
+if __name__ == "__main__":
+    main()

scripts/coling/coling.py

@@ -0,0 +1,128 @@
+import json
+import requests
+from bs4 import BeautifulSoup
+
+SOURCE_URL = "https://aclanthology.org/events/coling-{year}/"
+OUTPUT_FILE = "data/coling/coling{year}_papers.jsonl"
+BASE_URL = "https://aclanthology.org"
+
+
+def fetch_page(url):
+    headers = {"User-Agent": "Mozilla/5.0 (ACL-parser/1.0; research)"}
+    print(f"Fetching {url} ...", flush=True)
+    resp = requests.get(url, headers=headers, timeout=120)
+    resp.raise_for_status()
+    return resp.text
+
+
+def abs_url(href):
+    if not href:
+        return ""
+    return href if href.startswith("http") else BASE_URL + href
+
+
+def parse_papers(html):
+    soup = BeautifulSoup(html, "html.parser")
+    papers = []
+    
+    # Find all paper divs - each paper is in a div with class "d-sm-flex align-items-stretch mb-3"
+    paper_divs = soup.find_all("div", class_="d-sm-flex align-items-stretch mb-3")
+    
+    for paper_div in paper_divs:
+        paper = parse_paper_div(paper_div)
+        if paper:
+            papers.append(paper)
+    
+    return papers
+
+
+def parse_paper_div(paper_div):
+    # Extract the paper title and URL
+    title_element = paper_div.find("strong")
+    if not title_element:
+        return None
+    
+    title_link = title_element.find("a")
+    if not title_link:
+        return None
+    
+    title = title_link.get_text(strip=False)
+    href = title_link.get("href", "")
+    paper_id = href.strip("/").split("/")[-1] if href else ""
+    url = abs_url(href)
+    
+    # Skip if no paper_id found
+    if not paper_id:
+        return None
+    
+    # PDF / BIB links from the button-row div
+    pdf_url = bib_url = ""
+    btn_row = paper_div.find("div", class_="list-button-row")
+    if btn_row:
+        for a in btn_row.find_all("a", href=True):
+            text = a.get_text(strip=True).lower()
+            h = a["href"]
+            if text == "pdf" or h.endswith(".pdf"):
+                pdf_url = abs_url(h)
+            elif text == "bib" or h.endswith(".bib"):
+                bib_url = abs_url(h)
+    
+    # Authors: <a href="/people/..."> links inside the d-block span
+    authors = []
+    span = paper_div.find("span", class_="d-block")
+    if span:
+        for a in span.find_all("a", href=True):
+            if "/people/" in a["href"]:
+                authors.append(a.get_text(strip=True))
+    
+    # Abstract: look for the collapse div with abstract content
+    abstract = ""
+    # Find the abstract ID from the button
+    abs_button = paper_div.find("a", class_="badge text-bg-info")
+    if abs_button and "data-bs-target" in abs_button.attrs:
+        abs_id = abs_button["data-bs-target"].lstrip("#")
+        # Find the abstract div using this ID
+        abs_div = soup.find("div", id=abs_id)
+        if abs_div:
+            body = abs_div.find("div", class_="card-body")
+            if body:
+                abstract = body.get_text(strip=True)
+    
+    # Determine volume from paper_id
+    volume = ""
+    if paper_id:
+        parts = paper_id.split(".")
+        if len(parts) >= 2:
+            volume = parts[1]  # e.g., "acl-long" from "2023.acl-long.19"
+    
+    return {
+        "paper_id": paper_id,
+        "title": title,
+        "authors": authors,
+        "abstract": abstract,
+        "url": url,
+        "pdf_url": pdf_url,
+        "bib_url": bib_url,
+    }
+
+
+def main():
+    for year in range(0, 25, 2):
+        year = f"20{year:02d}"
+        try:
+            html = fetch_page(SOURCE_URL.format(year=year))
+            print("Parsing ...", flush=True)
+            papers = parse_papers(html)
+            
+            print(f"Found {len(papers)} papers. Writing to {OUTPUT_FILE.format(year=year)} ...", flush=True)
+            with open(OUTPUT_FILE.format(year=year), "w", encoding="utf-8") as f:
+                for p in papers:
+                    f.write(json.dumps(p, ensure_ascii=False) + "\n")
+            
+            print("Done")
+        except Exception as e:
+            print(f"Error: {e}")
+
+
+if __name__ == "__main__":
+    main()

scripts/coling/coling2025.py

@@ -0,0 +1,122 @@
+import json
+import requests
+from bs4 import BeautifulSoup
+
+SOURCE_URL = "https://aclanthology.org/events/coling-2025/"
+OUTPUT_FILE = "data/coling/coling2025_papers.jsonl"
+BASE_URL    = "https://aclanthology.org"
+
+
+def fetch_page(url):
+    headers = {"User-Agent": "Mozilla/5.0 (ACL-parser/1.0; research)"}
+    print(f"Fetching {url} ...", flush=True)
+    resp = requests.get(url, headers=headers, timeout=120)
+    resp.raise_for_status()
+    return resp.text
+
+
+def abs_url(href):
+    if not href:
+        return ""
+    return href if href.startswith("http") else BASE_URL + href
+
+
+def parse_papers(html):
+    soup = BeautifulSoup(html, "html.parser")
+    papers = []
+
+    # Each volume section is wrapped in <div id="2025acl-long"> etc.
+    volume_divs = soup.find_all("div", id=lambda i: i and i.startswith("2025"))
+
+    for vol_div in volume_divs:
+        volume_id = vol_div.get("id", "")
+
+        # Volume name is in the <a class="align-middle"> inside the <h4>
+        h4 = vol_div.find("h4")
+        if h4:
+            vol_link = h4.find("a", class_="align-middle")
+            volume_name = vol_link.get_text(strip=True) if vol_link else h4.get_text(strip=True)
+        else:
+            volume_name = volume_id
+
+        # Each paper is a <div class="d-sm-flex align-items-stretch mb-3">
+        for card in vol_div.find_all("div", class_="d-sm-flex align-items-stretch mb-3"):
+            paper = parse_card(card, volume_id, volume_name)
+            if paper:
+                papers.append(paper)
+
+    return papers
+
+
+def parse_card(card, volume_id, volume_name):
+    # Title
+    strong = card.find("strong")
+    if not strong:
+        return None
+    title_link = strong.find("a")
+    if not title_link:
+        return None
+
+    title = title_link.get_text(strip=False)
+    href = title_link.get("href", "")
+    paper_id = href.strip("/")
+    url = abs_url(href)
+
+    # Skip front-matter entries (end with ".0")
+    if paper_id.endswith(".0"):
+        return None
+
+    # PDF / BIB from the button-row div
+    pdf_url = bib_url = ""
+    btn_row = card.find("div", class_="list-button-row")
+    if btn_row:
+        for a in btn_row.find_all("a", href=True):
+            text = a.get_text(strip=True).lower()
+            h    = a["href"]
+            if text == "pdf" or h.endswith(".pdf"):
+                pdf_url = abs_url(h)
+            elif text == "bib" or h.endswith(".bib"):
+                bib_url = abs_url(h)
+
+    # Authors: <a href="/people/..."> links inside the d-block span
+    authors = []
+    span = card.find("span", class_="d-block")
+    if span:
+        for a in span.find_all("a", href=True):
+            if "/people/" in a["href"]:
+                authors.append(a.get_text(strip=True))
+
+    # Abstract: next sibling div with class "abstract-collapse"
+    abstract = ""
+    nxt = card.find_next_sibling()
+    if nxt and "abstract-collapse" in nxt.get("class", []):
+        body = nxt.find("div", class_="card-body")
+        if body:
+            abstract = body.get_text(strip=True)
+
+    return {
+        "paper_id":  paper_id,
+        "title":     title,
+        "authors":   authors,
+        "abstract":  abstract,
+        "url":       url,
+        "pdf_url":   pdf_url,
+        "bib_url":   bib_url,
+    }
+
+
+def main():
+    html = fetch_page(SOURCE_URL)
+    print("Parsing ...", flush=True)
+    papers = parse_papers(html)
+
+    print(f"Found {len(papers)} papers. Writing to {OUTPUT_FILE} ...", flush=True)
+    with open(OUTPUT_FILE, "w", encoding="utf-8") as f:
+        for p in papers:
+            f.write(json.dumps(p, ensure_ascii=False) + "\n")
+
+    print("Done")
+
+
+if __name__ == "__main__":
+    main()

scripts/conll/conll.py

@@ -0,0 +1,128 @@
+import json
+import requests
+from bs4 import BeautifulSoup
+
+SOURCE_URL = "https://aclanthology.org/events/conll-{year}/"
+OUTPUT_FILE = "data/conll/conll{year}_papers.jsonl"
+BASE_URL = "https://aclanthology.org"
+
+
+def fetch_page(url):
+    headers = {"User-Agent": "Mozilla/5.0 (ACL-parser/1.0; research)"}
+    print(f"Fetching {url} ...", flush=True)
+    resp = requests.get(url, headers=headers, timeout=120)
+    resp.raise_for_status()
+    return resp.text
+
+
+def abs_url(href):
+    if not href:
+        return ""
+    return href if href.startswith("http") else BASE_URL + href
+
+
+def parse_papers(html):
+    soup = BeautifulSoup(html, "html.parser")
+    papers = []
+    
+    # Find all paper divs - each paper is in a div with class "d-sm-flex align-items-stretch mb-3"
+    paper_divs = soup.find_all("div", class_="d-sm-flex align-items-stretch mb-3")
+    
+    for paper_div in paper_divs:
+        paper = parse_paper_div(paper_div)
+        if paper:
+            papers.append(paper)
+    
+    return papers
+
+
+def parse_paper_div(paper_div):
+    # Extract the paper title and URL
+    title_element = paper_div.find("strong")
+    if not title_element:
+        return None
+    
+    title_link = title_element.find("a")
+    if not title_link:
+        return None
+    
+    title = title_link.get_text(strip=False)
+    href = title_link.get("href", "")
+    paper_id = href.strip("/").split("/")[-1] if href else ""
+    url = abs_url(href)
+    
+    # Skip if no paper_id found
+    if not paper_id:
+        return None
+    
+    # PDF / BIB links from the button-row div
+    pdf_url = bib_url = ""
+    btn_row = paper_div.find("div", class_="list-button-row")
+    if btn_row:
+        for a in btn_row.find_all("a", href=True):
+            text = a.get_text(strip=True).lower()
+            h = a["href"]
+            if text == "pdf" or h.endswith(".pdf"):
+                pdf_url = abs_url(h)
+            elif text == "bib" or h.endswith(".bib"):
+                bib_url = abs_url(h)
+    
+    # Authors: <a href="/people/..."> links inside the d-block span
+    authors = []
+    span = paper_div.find("span", class_="d-block")
+    if span:
+        for a in span.find_all("a", href=True):
+            if "/people/" in a["href"]:
+                authors.append(a.get_text(strip=True))
+    
+    # Abstract: look for the collapse div with abstract content
+    abstract = ""
+    # Find the abstract ID from the button
+    abs_button = paper_div.find("a", class_="badge text-bg-info")
+    if abs_button and "data-bs-target" in abs_button.attrs:
+        abs_id = abs_button["data-bs-target"].lstrip("#")
+        # Find the abstract div using this ID
+        abs_div = soup.find("div", id=abs_id)
+        if abs_div:
+            body = abs_div.find("div", class_="card-body")
+            if body:
+                abstract = body.get_text(strip=True)
+    
+    # Determine volume from paper_id
+    volume = ""
+    if paper_id:
+        parts = paper_id.split(".")
+        if len(parts) >= 2:
+            volume = parts[1]  # e.g., "acl-long" from "2023.acl-long.19"
+    
+    return {
+        "paper_id": paper_id,
+        "title": title,
+        "authors": authors,
+        "abstract": abstract,
+        "url": url,
+        "pdf_url": pdf_url,
+        "bib_url": bib_url,
+    }
+
+
+def main():
+    for year in range(25):
+        year = f"20{year:02d}"
+        try:
+            html = fetch_page(SOURCE_URL.format(year=year))
+            print("Parsing ...", flush=True)
+            papers = parse_papers(html)
+            
+            print(f"Found {len(papers)} papers. Writing to {OUTPUT_FILE.format(year=year)} ...", flush=True)
+            with open(OUTPUT_FILE.format(year=year), "w", encoding="utf-8") as f:
+                for p in papers:
+                    f.write(json.dumps(p, ensure_ascii=False) + "\n")
+            
+            print("Done")
+        except Exception as e:
+            print(f"Error: {e}")
+
+
+if __name__ == "__main__":
+    main()

scripts/conll/conll2025.py

@@ -0,0 +1,122 @@
+import json
+import requests
+from bs4 import BeautifulSoup
+
+SOURCE_URL = "https://aclanthology.org/events/conll-2025/"
+OUTPUT_FILE = "data/conll/conll2025_papers.jsonl"
+BASE_URL    = "https://aclanthology.org"
+
+
+def fetch_page(url):
+    headers = {"User-Agent": "Mozilla/5.0 (ACL-parser/1.0; research)"}
+    print(f"Fetching {url} ...", flush=True)
+    resp = requests.get(url, headers=headers, timeout=120)
+    resp.raise_for_status()
+    return resp.text
+
+
+def abs_url(href):
+    if not href:
+        return ""
+    return href if href.startswith("http") else BASE_URL + href
+
+
+def parse_papers(html):
+    soup = BeautifulSoup(html, "html.parser")
+    papers = []
+
+    # Each volume section is wrapped in <div id="2025acl-long"> etc.
+    volume_divs = soup.find_all("div", id=lambda i: i and i.startswith("2025"))
+
+    for vol_div in volume_divs:
+        volume_id = vol_div.get("id", "")
+
+        # Volume name is in the <a class="align-middle"> inside the <h4>
+        h4 = vol_div.find("h4")
+        if h4:
+            vol_link = h4.find("a", class_="align-middle")
+            volume_name = vol_link.get_text(strip=True) if vol_link else h4.get_text(strip=True)
+        else:
+            volume_name = volume_id
+
+        # Each paper is a <div class="d-sm-flex align-items-stretch mb-3">
+        for card in vol_div.find_all("div", class_="d-sm-flex align-items-stretch mb-3"):
+            paper = parse_card(card, volume_id, volume_name)
+            if paper:
+                papers.append(paper)
+
+    return papers
+
+
+def parse_card(card, volume_id, volume_name):
+    # Title
+    strong = card.find("strong")
+    if not strong:
+        return None
+    title_link = strong.find("a")
+    if not title_link:
+        return None
+
+    title = title_link.get_text(strip=False)
+    href = title_link.get("href", "")
+    paper_id = href.strip("/")
+    url = abs_url(href)
+
+    # Skip front-matter entries (end with ".0")
+    if paper_id.endswith(".0"):
+        return None
+
+    # PDF / BIB from the button-row div
+    pdf_url = bib_url = ""
+    btn_row = card.find("div", class_="list-button-row")
+    if btn_row:
+        for a in btn_row.find_all("a", href=True):
+            text = a.get_text(strip=True).lower()
+            h    = a["href"]
+            if text == "pdf" or h.endswith(".pdf"):
+                pdf_url = abs_url(h)
+            elif text == "bib" or h.endswith(".bib"):
+                bib_url = abs_url(h)
+
+    # Authors: <a href="/people/..."> links inside the d-block span
+    authors = []
+    span = card.find("span", class_="d-block")
+    if span:
+        for a in span.find_all("a", href=True):
+            if "/people/" in a["href"]:
+                authors.append(a.get_text(strip=True))
+
+    # Abstract: next sibling div with class "abstract-collapse"
+    abstract = ""
+    nxt = card.find_next_sibling()
+    if nxt and "abstract-collapse" in nxt.get("class", []):
+        body = nxt.find("div", class_="card-body")
+        if body:
+            abstract = body.get_text(strip=True)
+
+    return {
+        "paper_id":  paper_id,
+        "title":     title,
+        "authors":   authors,
+        "abstract":  abstract,
+        "url":       url,
+        "pdf_url":   pdf_url,
+        "bib_url":   bib_url,
+    }
+
+
+def main():
+    html = fetch_page(SOURCE_URL)
+    print("Parsing ...", flush=True)
+    papers = parse_papers(html)
+
+    print(f"Found {len(papers)} papers. Writing to {OUTPUT_FILE} ...", flush=True)
+    with open(OUTPUT_FILE, "w", encoding="utf-8") as f:
+        for p in papers:
+            f.write(json.dumps(p, ensure_ascii=False) + "\n")
+
+    print("Done")
+
+
+if __name__ == "__main__":
+    main()

scripts/eacl/eacl.py

@@ -0,0 +1,130 @@
+import json
+import requests
+from bs4 import BeautifulSoup
+
+SOURCE_URL = "https://aclanthology.org/events/eacl-{year}/"
+OUTPUT_FILE = "data/eacl/eacl{year}_papers.jsonl"
+BASE_URL = "https://aclanthology.org"
+
+
+def fetch_page(url):
+    headers = {"User-Agent": "Mozilla/5.0 (ACL-parser/1.0; research)"}
+    print(f"Fetching {url} ...", flush=True)
+    resp = requests.get(url, headers=headers, timeout=120)
+    resp.raise_for_status()
+    # with open("acl.txt", "w") as f:
+    #     f.write(resp.text)
+    return resp.text
+
+
+def abs_url(href):
+    if not href:
+        return ""
+    return href if href.startswith("http") else BASE_URL + href
+
+
+def parse_papers(html):
+    soup = BeautifulSoup(html, "html.parser")
+    papers = []
+    
+    # Find all paper divs - each paper is in a div with class "d-sm-flex align-items-stretch mb-3"
+    paper_divs = soup.find_all("div", class_="d-sm-flex align-items-stretch mb-3")
+    
+    for paper_div in paper_divs:
+        paper = parse_paper_div(paper_div)
+        if paper:
+            papers.append(paper)
+    
+    return papers
+
+
+def parse_paper_div(paper_div):
+    # Extract the paper title and URL
+    title_element = paper_div.find("strong")
+    if not title_element:
+        return None
+    
+    title_link = title_element.find("a")
+    if not title_link:
+        return None
+    
+    title = title_link.get_text(strip=False)
+    href = title_link.get("href", "")
+    paper_id = href.strip("/").split("/")[-1] if href else ""
+    url = abs_url(href)
+    
+    # Skip if no paper_id found
+    if not paper_id:
+        return None
+    
+    # PDF / BIB links from the button-row div
+    pdf_url = bib_url = ""
+    btn_row = paper_div.find("div", class_="list-button-row")
+    if btn_row:
+        for a in btn_row.find_all("a", href=True):
+            text = a.get_text(strip=True).lower()
+            h = a["href"]
+            if text == "pdf" or h.endswith(".pdf"):
+                pdf_url = abs_url(h)
+            elif text == "bib" or h.endswith(".bib"):
+                bib_url = abs_url(h)
+    
+    # Authors: <a href="/people/..."> links inside the d-block span
+    authors = []
+    span = paper_div.find("span", class_="d-block")
+    if span:
+        for a in span.find_all("a", href=True):
+            if "/people/" in a["href"]:
+                authors.append(a.get_text(strip=True))
+    
+    # Abstract: look for the collapse div with abstract content
+    abstract = ""
+    # Find the abstract ID from the button
+    abs_button = paper_div.find("a", class_="badge text-bg-info")
+    if abs_button and "data-bs-target" in abs_button.attrs:
+        abs_id = abs_button["data-bs-target"].lstrip("#")
+        # Find the abstract div using this ID
+        abs_div = soup.find("div", id=abs_id)
+        if abs_div:
+            body = abs_div.find("div", class_="card-body")
+            if body:
+                abstract = body.get_text(strip=True)
+    
+    # Determine volume from paper_id
+    volume = ""
+    if paper_id:
+        parts = paper_id.split(".")
+        if len(parts) >= 2:
+            volume = parts[1]  # e.g., "acl-long" from "2023.acl-long.19"
+    
+    return {
+        "paper_id": paper_id,
+        "title": title,
+        "authors": authors,
+        "abstract": abstract,
+        "url": url,
+        "pdf_url": pdf_url,
+        "bib_url": bib_url,
+    }
+
+
+def main():
+    for year in [24, 23, 21, 17, 14, 12, 9, 6, 3]:
+        year = f"20{year:02d}"
+        try:
+            html = fetch_page(SOURCE_URL.format(year=year))
+            print("Parsing ...", flush=True)
+            papers = parse_papers(html)
+            
+            print(f"Found {len(papers)} papers. Writing to {OUTPUT_FILE.format(year=year)} ...", flush=True)
+            with open(OUTPUT_FILE.format(year=year), "w", encoding="utf-8") as f:
+                for p in papers:
+                    f.write(json.dumps(p, ensure_ascii=False) + "\n")
+            
+            print("Done")
+        except Exception as e:
+            print(f"Error: {e}")
+
+
+if __name__ == "__main__":
+    main()

scripts/eacl/eacl2026.py

@@ -0,0 +1,122 @@
+import json
+import requests
+from bs4 import BeautifulSoup
+
+SOURCE_URL = "https://aclanthology.org/events/eacl-2026/"
+OUTPUT_FILE = "data/eacl/eacl2026_papers.jsonl"
+BASE_URL    = "https://aclanthology.org"
+
+
+def fetch_page(url):
+    headers = {"User-Agent": "Mozilla/5.0 (ACL-parser/1.0; research)"}
+    print(f"Fetching {url} ...", flush=True)
+    resp = requests.get(url, headers=headers, timeout=120)
+    resp.raise_for_status()
+    return resp.text
+
+
+def abs_url(href):
+    if not href:
+        return ""
+    return href if href.startswith("http") else BASE_URL + href
+
+
+def parse_papers(html):
+    soup = BeautifulSoup(html, "html.parser")
+    papers = []
+
+    # Each volume section is wrapped in <div id="2025acl-long"> etc.
+    volume_divs = soup.find_all("div", id=lambda i: i and i.startswith("2026"))
+
+    for vol_div in volume_divs:
+        volume_id = vol_div.get("id", "")
+
+        # Volume name is in the <a class="align-middle"> inside the <h4>
+        h4 = vol_div.find("h4")
+        if h4:
+            vol_link = h4.find("a", class_="align-middle")
+            volume_name = vol_link.get_text(strip=True) if vol_link else h4.get_text(strip=True)
+        else:
+            volume_name = volume_id
+
+        # Each paper is a <div class="d-sm-flex align-items-stretch mb-3">
+        for card in vol_div.find_all("div", class_="d-sm-flex align-items-stretch mb-3"):
+            paper = parse_card(card, volume_id, volume_name)
+            if paper:
+                papers.append(paper)
+
+    return papers
+
+
+def parse_card(card, volume_id, volume_name):
+    # Title
+    strong = card.find("strong")
+    if not strong:
+        return None
+    title_link = strong.find("a")
+    if not title_link:
+        return None
+
+    title = title_link.get_text(strip=False)
+    href = title_link.get("href", "")
+    paper_id = href.strip("/")
+    url = abs_url(href)
+
+    # Skip front-matter entries (end with ".0")
+    if paper_id.endswith(".0"):
+        return None
+
+    # PDF / BIB from the button-row div
+    pdf_url = bib_url = ""
+    btn_row = card.find("div", class_="list-button-row")
+    if btn_row:
+        for a in btn_row.find_all("a", href=True):
+            text = a.get_text(strip=True).lower()
+            h    = a["href"]
+            if text == "pdf" or h.endswith(".pdf"):
+                pdf_url = abs_url(h)
+            elif text == "bib" or h.endswith(".bib"):
+                bib_url = abs_url(h)
+
+    # Authors: <a href="/people/..."> links inside the d-block span
+    authors = []
+    span = card.find("span", class_="d-block")
+    if span:
+        for a in span.find_all("a", href=True):
+            if "/people/" in a["href"]:
+                authors.append(a.get_text(strip=True))
+
+    # Abstract: next sibling div with class "abstract-collapse"
+    abstract = ""
+    nxt = card.find_next_sibling()
+    if nxt and "abstract-collapse" in nxt.get("class", []):
+        body = nxt.find("div", class_="card-body")
+        if body:
+            abstract = body.get_text(strip=True)
+
+    return {
+        "paper_id":  paper_id,
+        "title":     title,
+        "authors":   authors,
+        "abstract":  abstract,
+        "url":       url,
+        "pdf_url":   pdf_url,
+        "bib_url":   bib_url,
+    }
+
+
+def main():
+    html = fetch_page(SOURCE_URL)
+    print("Parsing ...", flush=True)
+    papers = parse_papers(html)
+
+    print(f"Found {len(papers)} papers. Writing to {OUTPUT_FILE} ...", flush=True)
+    with open(OUTPUT_FILE, "w", encoding="utf-8") as f:
+        for p in papers:
+            f.write(json.dumps(p, ensure_ascii=False) + "\n")
+
+    print("Done")
+
+
+if __name__ == "__main__":
+    main()

scripts/emnlp/emnlp.py

@@ -0,0 +1,130 @@
+import json
+import requests
+from bs4 import BeautifulSoup
+
+SOURCE_URL = "https://aclanthology.org/events/emnlp-{year}/"
+OUTPUT_FILE = "data/emnlp/emnlp{year}_papers.jsonl"
+BASE_URL = "https://aclanthology.org"
+
+
+def fetch_page(url):
+    headers = {"User-Agent": "Mozilla/5.0 (ACL-parser/1.0; research)"}
+    print(f"Fetching {url} ...", flush=True)
+    resp = requests.get(url, headers=headers, timeout=120)
+    resp.raise_for_status()
+    # with open("acl.txt", "w") as f:
+    #     f.write(resp.text)
+    return resp.text
+
+
+def abs_url(href):
+    if not href:
+        return ""
+    return href if href.startswith("http") else BASE_URL + href
+
+
+def parse_papers(html):
+    soup = BeautifulSoup(html, "html.parser")
+    papers = []
+    
+    # Find all paper divs - each paper is in a div with class "d-sm-flex align-items-stretch mb-3"
+    paper_divs = soup.find_all("div", class_="d-sm-flex align-items-stretch mb-3")
+    
+    for paper_div in paper_divs:
+        paper = parse_paper_div(paper_div)
+        if paper:
+            papers.append(paper)
+    
+    return papers
+
+
+def parse_paper_div(paper_div):
+    # Extract the paper title and URL
+    title_element = paper_div.find("strong")
+    if not title_element:
+        return None
+    
+    title_link = title_element.find("a")
+    if not title_link:
+        return None
+    
+    title = title_link.get_text(strip=False)
+    href = title_link.get("href", "")
+    paper_id = href.strip("/").split("/")[-1] if href else ""
+    url = abs_url(href)
+    
+    # Skip if no paper_id found
+    if not paper_id:
+        return None
+    
+    # PDF / BIB links from the button-row div
+    pdf_url = bib_url = ""
+    btn_row = paper_div.find("div", class_="list-button-row")
+    if btn_row:
+        for a in btn_row.find_all("a", href=True):
+            text = a.get_text(strip=True).lower()
+            h = a["href"]
+            if text == "pdf" or h.endswith(".pdf"):
+                pdf_url = abs_url(h)
+            elif text == "bib" or h.endswith(".bib"):
+                bib_url = abs_url(h)
+    
+    # Authors: <a href="/people/..."> links inside the d-block span
+    authors = []
+    span = paper_div.find("span", class_="d-block")
+    if span:
+        for a in span.find_all("a", href=True):
+            if "/people/" in a["href"]:
+                authors.append(a.get_text(strip=True))
+    
+    # Abstract: look for the collapse div with abstract content
+    abstract = ""
+    # Find the abstract ID from the button
+    abs_button = paper_div.find("a", class_="badge text-bg-info")
+    if abs_button and "data-bs-target" in abs_button.attrs:
+        abs_id = abs_button["data-bs-target"].lstrip("#")
+        # Find the abstract div using this ID
+        abs_div = soup.find("div", id=abs_id)
+        if abs_div:
+            body = abs_div.find("div", class_="card-body")
+            if body:
+                abstract = body.get_text(strip=True)
+    
+    # Determine volume from paper_id
+    volume = ""
+    if paper_id:
+        parts = paper_id.split(".")
+        if len(parts) >= 2:
+            volume = parts[1]  # e.g., "acl-long" from "2023.acl-long.19"
+    
+    return {
+        "paper_id": paper_id,
+        "title": title,
+        "authors": authors,
+        "abstract": abstract,
+        "url": url,
+        "pdf_url": pdf_url,
+        "bib_url": bib_url,
+    }
+
+
+def main():
+    for year in range(25):
+        year = f"20{year:02d}"
+        try:
+            html = fetch_page(SOURCE_URL.format(year=year))
+            print("Parsing ...", flush=True)
+            papers = parse_papers(html)
+            
+            print(f"Found {len(papers)} papers. Writing to {OUTPUT_FILE.format(year=year)} ...", flush=True)
+            with open(OUTPUT_FILE.format(year=year), "w", encoding="utf-8") as f:
+                for p in papers:
+                    f.write(json.dumps(p, ensure_ascii=False) + "\n")
+            
+            print("Done")
+        except Exception as e:
+            print(f"Error: {e}")
+
+
+if __name__ == "__main__":
+    main()

scripts/emnlp/emnlp2025.py

@@ -0,0 +1,122 @@
+import json
+import requests
+from bs4 import BeautifulSoup
+
+SOURCE_URL = "https://aclanthology.org/events/emnlp-2025/"
+OUTPUT_FILE = "data/emnlp/emnlp2025_papers.jsonl"
+BASE_URL    = "https://aclanthology.org"
+
+
+def fetch_page(url):
+    headers = {"User-Agent": "Mozilla/5.0 (ACL-parser/1.0; research)"}
+    print(f"Fetching {url} ...", flush=True)
+    resp = requests.get(url, headers=headers, timeout=120)
+    resp.raise_for_status()
+    return resp.text
+
+
+def abs_url(href):
+    if not href:
+        return ""
+    return href if href.startswith("http") else BASE_URL + href
+
+
+def parse_papers(html):
+    soup = BeautifulSoup(html, "html.parser")
+    papers = []
+
+    # Each volume section is wrapped in <div id="2025acl-long"> etc.
+    volume_divs = soup.find_all("div", id=lambda i: i and i.startswith("2025"))
+
+    for vol_div in volume_divs:
+        volume_id = vol_div.get("id", "")
+
+        # Volume name is in the <a class="align-middle"> inside the <h4>
+        h4 = vol_div.find("h4")
+        if h4:
+            vol_link = h4.find("a", class_="align-middle")
+            volume_name = vol_link.get_text(strip=True) if vol_link else h4.get_text(strip=True)
+        else:
+            volume_name = volume_id
+
+        # Each paper is a <div class="d-sm-flex align-items-stretch mb-3">
+        for card in vol_div.find_all("div", class_="d-sm-flex align-items-stretch mb-3"):
+            paper = parse_card(card, volume_id, volume_name)
+            if paper:
+                papers.append(paper)
+
+    return papers
+
+
+def parse_card(card, volume_id, volume_name):
+    # Title
+    strong = card.find("strong")
+    if not strong:
+        return None
+    title_link = strong.find("a")
+    if not title_link:
+        return None
+
+    title = title_link.get_text(strip=False)
+    href = title_link.get("href", "")
+    paper_id = href.strip("/")
+    url = abs_url(href)
+
+    # Skip front-matter entries (end with ".0")
+    if paper_id.endswith(".0"):
+        return None
+
+    # PDF / BIB from the button-row div
+    pdf_url = bib_url = ""
+    btn_row = card.find("div", class_="list-button-row")
+    if btn_row:
+        for a in btn_row.find_all("a", href=True):
+            text = a.get_text(strip=True).lower()
+            h    = a["href"]
+            if text == "pdf" or h.endswith(".pdf"):
+                pdf_url = abs_url(h)
+            elif text == "bib" or h.endswith(".bib"):
+                bib_url = abs_url(h)
+
+    # Authors: <a href="/people/..."> links inside the d-block span
+    authors = []
+    span = card.find("span", class_="d-block")
+    if span:
+        for a in span.find_all("a", href=True):
+            if "/people/" in a["href"]:
+                authors.append(a.get_text(strip=True))
+
+    # Abstract: next sibling div with class "abstract-collapse"
+    abstract = ""
+    nxt = card.find_next_sibling()
+    if nxt and "abstract-collapse" in nxt.get("class", []):
+        body = nxt.find("div", class_="card-body")
+        if body:
+            abstract = body.get_text(strip=True)
+
+    return {
+        "paper_id":  paper_id,
+        "title":     title,
+        "authors":   authors,
+        "abstract":  abstract,
+        "url":       url,
+        "pdf_url":   pdf_url,
+        "bib_url":   bib_url,
+    }
+
+
+def main():
+    html = fetch_page(SOURCE_URL)
+    print("Parsing ...", flush=True)
+    papers = parse_papers(html)
+
+    print(f"Found {len(papers)} papers. Writing to {OUTPUT_FILE} ...", flush=True)
+    with open(OUTPUT_FILE, "w", encoding="utf-8") as f:
+        for p in papers:
+            f.write(json.dumps(p, ensure_ascii=False) + "\n")
+
+    print("Done")
+
+
+if __name__ == "__main__":
+    main()

scripts/ijcnlp/ijcnlp.py

@@ -0,0 +1,128 @@
+import json
+import requests
+from bs4 import BeautifulSoup
+
+SOURCE_URL = "https://aclanthology.org/events/ijcnlp-{year}/"
+OUTPUT_FILE = "data/ijcnlp/ijcnlp{year}_papers.jsonl"
+BASE_URL = "https://aclanthology.org"
+
+
+def fetch_page(url):
+    headers = {"User-Agent": "Mozilla/5.0 (ACL-parser/1.0; research)"}
+    print(f"Fetching {url} ...", flush=True)
+    resp = requests.get(url, headers=headers, timeout=120)
+    resp.raise_for_status()
+    return resp.text
+
+
+def abs_url(href):
+    if not href:
+        return ""
+    return href if href.startswith("http") else BASE_URL + href
+
+
+def parse_papers(html):
+    soup = BeautifulSoup(html, "html.parser")
+    papers = []
+    
+    # Find all paper divs - each paper is in a div with class "d-sm-flex align-items-stretch mb-3"
+    paper_divs = soup.find_all("div", class_="d-sm-flex align-items-stretch mb-3")
+    
+    for paper_div in paper_divs:
+        paper = parse_paper_div(paper_div)
+        if paper:
+            papers.append(paper)
+    
+    return papers
+
+
+def parse_paper_div(paper_div):
+    # Extract the paper title and URL
+    title_element = paper_div.find("strong")
+    if not title_element:
+        return None
+    
+    title_link = title_element.find("a")
+    if not title_link:
+        return None
+    
+    title = title_link.get_text(strip=False)
+    href = title_link.get("href", "")
+    paper_id = href.strip("/").split("/")[-1] if href else ""
+    url = abs_url(href)
+    
+    # Skip if no paper_id found
+    if not paper_id:
+        return None
+    
+    # PDF / BIB links from the button-row div
+    pdf_url = bib_url = ""
+    btn_row = paper_div.find("div", class_="list-button-row")
+    if btn_row:
+        for a in btn_row.find_all("a", href=True):
+            text = a.get_text(strip=True).lower()
+            h = a["href"]
+            if text == "pdf" or h.endswith(".pdf"):
+                pdf_url = abs_url(h)
+            elif text == "bib" or h.endswith(".bib"):
+                bib_url = abs_url(h)
+    
+    # Authors: <a href="/people/..."> links inside the d-block span
+    authors = []
+    span = paper_div.find("span", class_="d-block")
+    if span:
+        for a in span.find_all("a", href=True):
+            if "/people/" in a["href"]:
+                authors.append(a.get_text(strip=True))
+    
+    # Abstract: look for the collapse div with abstract content
+    abstract = ""
+    # Find the abstract ID from the button
+    abs_button = paper_div.find("a", class_="badge text-bg-info")
+    if abs_button and "data-bs-target" in abs_button.attrs:
+        abs_id = abs_button["data-bs-target"].lstrip("#")
+        # Find the abstract div using this ID
+        abs_div = soup.find("div", id=abs_id)
+        if abs_div:
+            body = abs_div.find("div", class_="card-body")
+            if body:
+                abstract = body.get_text(strip=True)
+    
+    # Determine volume from paper_id
+    volume = ""
+    if paper_id:
+        parts = paper_id.split(".")
+        if len(parts) >= 2:
+            volume = parts[1]  # e.g., "acl-long" from "2023.acl-long.19"
+    
+    return {
+        "paper_id": paper_id,
+        "title": title,
+        "authors": authors,
+        "abstract": abstract,
+        "url": url,
+        "pdf_url": pdf_url,
+        "bib_url": bib_url,
+    }
+
+
+def main():
+    for year in [23, 22, 21, 19, 17, 15, 13, 11, 9, 8, 5]:
+        year = f"20{year:02d}"
+        try:
+            html = fetch_page(SOURCE_URL.format(year=year))
+            print("Parsing ...", flush=True)
+            papers = parse_papers(html)
+            
+            print(f"Found {len(papers)} papers. Writing to {OUTPUT_FILE.format(year=year)} ...", flush=True)
+            with open(OUTPUT_FILE.format(year=year), "w", encoding="utf-8") as f:
+                for p in papers:
+                    f.write(json.dumps(p, ensure_ascii=False) + "\n")
+            
+            print("Done")
+        except Exception as e:
+            print(f"Error: {e}")
+
+
+if __name__ == "__main__":
+    main()

scripts/ijcnlp/ijcnlp2025.py

@@ -0,0 +1,122 @@
+import json
+import requests
+from bs4 import BeautifulSoup
+
+SOURCE_URL = "https://aclanthology.org/events/ijcnlp-2025/"
+OUTPUT_FILE = "data/ijcnlp/ijcnlp2025_papers.jsonl"
+BASE_URL    = "https://aclanthology.org"
+
+
+def fetch_page(url):
+    headers = {"User-Agent": "Mozilla/5.0 (ACL-parser/1.0; research)"}
+    print(f"Fetching {url} ...", flush=True)
+    resp = requests.get(url, headers=headers, timeout=120)
+    resp.raise_for_status()
+    return resp.text
+
+
+def abs_url(href):
+    if not href:
+        return ""
+    return href if href.startswith("http") else BASE_URL + href
+
+
+def parse_papers(html):
+    soup = BeautifulSoup(html, "html.parser")
+    papers = []
+
+    # Each volume section is wrapped in <div id="2025acl-long"> etc.
+    volume_divs = soup.find_all("div", id=lambda i: i and i.startswith("2025"))
+
+    for vol_div in volume_divs:
+        volume_id = vol_div.get("id", "")
+
+        # Volume name is in the <a class="align-middle"> inside the <h4>
+        h4 = vol_div.find("h4")
+        if h4:
+            vol_link = h4.find("a", class_="align-middle")
+            volume_name = vol_link.get_text(strip=True) if vol_link else h4.get_text(strip=True)
+        else:
+            volume_name = volume_id
+
+        # Each paper is a <div class="d-sm-flex align-items-stretch mb-3">
+        for card in vol_div.find_all("div", class_="d-sm-flex align-items-stretch mb-3"):
+            paper = parse_card(card, volume_id, volume_name)
+            if paper:
+                papers.append(paper)
+
+    return papers
+
+
+def parse_card(card, volume_id, volume_name):
+    # Title
+    strong = card.find("strong")
+    if not strong:
+        return None
+    title_link = strong.find("a")
+    if not title_link:
+        return None
+
+    title = title_link.get_text(strip=False)
+    href = title_link.get("href", "")
+    paper_id = href.strip("/")
+    url = abs_url(href)
+
+    # Skip front-matter entries (end with ".0")
+    if paper_id.endswith(".0"):
+        return None
+
+    # PDF / BIB from the button-row div
+    pdf_url = bib_url = ""
+    btn_row = card.find("div", class_="list-button-row")
+    if btn_row:
+        for a in btn_row.find_all("a", href=True):
+            text = a.get_text(strip=True).lower()
+            h    = a["href"]
+            if text == "pdf" or h.endswith(".pdf"):
+                pdf_url = abs_url(h)
+            elif text == "bib" or h.endswith(".bib"):
+                bib_url = abs_url(h)
+
+    # Authors: <a href="/people/..."> links inside the d-block span
+    authors = []
+    span = card.find("span", class_="d-block")
+    if span:
+        for a in span.find_all("a", href=True):
+            if "/people/" in a["href"]:
+                authors.append(a.get_text(strip=True))
+
+    # Abstract: next sibling div with class "abstract-collapse"
+    abstract = ""
+    nxt = card.find_next_sibling()
+    if nxt and "abstract-collapse" in nxt.get("class", []):
+        body = nxt.find("div", class_="card-body")
+        if body:
+            abstract = body.get_text(strip=True)
+
+    return {
+        "paper_id":  paper_id,
+        "title":     title,
+        "authors":   authors,
+        "abstract":  abstract,
+        "url":       url,
+        "pdf_url":   pdf_url,
+        "bib_url":   bib_url,
+    }
+
+
+def main():
+    html = fetch_page(SOURCE_URL)
+    print("Parsing ...", flush=True)
+    papers = parse_papers(html)
+
+    print(f"Found {len(papers)} papers. Writing to {OUTPUT_FILE} ...", flush=True)
+    with open(OUTPUT_FILE, "w", encoding="utf-8") as f:
+        for p in papers:
+            f.write(json.dumps(p, ensure_ascii=False) + "\n")
+
+    print("Done")
+
+
+if __name__ == "__main__":
+    main()

scripts/iwslt/iwslt.py

@@ -0,0 +1,128 @@
+import json
+import requests
+from bs4 import BeautifulSoup
+
+SOURCE_URL = "https://aclanthology.org/events/iwslt-{year}/"
+OUTPUT_FILE = "data/iwslt/iwslt{year}_papers.jsonl"
+BASE_URL = "https://aclanthology.org"
+
+
+def fetch_page(url):
+    headers = {"User-Agent": "Mozilla/5.0 (ACL-parser/1.0; research)"}
+    print(f"Fetching {url} ...", flush=True)
+    resp = requests.get(url, headers=headers, timeout=120)
+    resp.raise_for_status()
+    return resp.text
+
+
+def abs_url(href):
+    if not href:
+        return ""
+    return href if href.startswith("http") else BASE_URL + href
+
+
+def parse_papers(html):
+    soup = BeautifulSoup(html, "html.parser")
+    papers = []
+    
+    # Find all paper divs - each paper is in a div with class "d-sm-flex align-items-stretch mb-3"
+    paper_divs = soup.find_all("div", class_="d-sm-flex align-items-stretch mb-3")
+    
+    for paper_div in paper_divs:
+        paper = parse_paper_div(paper_div)
+        if paper:
+            papers.append(paper)
+    
+    return papers
+
+
+def parse_paper_div(paper_div):
+    # Extract the paper title and URL
+    title_element = paper_div.find("strong")
+    if not title_element:
+        return None
+    
+    title_link = title_element.find("a")
+    if not title_link:
+        return None
+    
+    title = title_link.get_text(strip=False)
+    href = title_link.get("href", "")
+    paper_id = href.strip("/").split("/")[-1] if href else ""
+    url = abs_url(href)
+    
+    # Skip if no paper_id found
+    if not paper_id:
+        return None
+    
+    # PDF / BIB links from the button-row div
+    pdf_url = bib_url = ""
+    btn_row = paper_div.find("div", class_="list-button-row")
+    if btn_row:
+        for a in btn_row.find_all("a", href=True):
+            text = a.get_text(strip=True).lower()
+            h = a["href"]
+            if text == "pdf" or h.endswith(".pdf"):
+                pdf_url = abs_url(h)
+            elif text == "bib" or h.endswith(".bib"):
+                bib_url = abs_url(h)
+    
+    # Authors: <a href="/people/..."> links inside the d-block span
+    authors = []
+    span = paper_div.find("span", class_="d-block")
+    if span:
+        for a in span.find_all("a", href=True):
+            if "/people/" in a["href"]:
+                authors.append(a.get_text(strip=True))
+    
+    # Abstract: look for the collapse div with abstract content
+    abstract = ""
+    # Find the abstract ID from the button
+    abs_button = paper_div.find("a", class_="badge text-bg-info")
+    if abs_button and "data-bs-target" in abs_button.attrs:
+        abs_id = abs_button["data-bs-target"].lstrip("#")
+        # Find the abstract div using this ID
+        abs_div = soup.find("div", id=abs_id)
+        if abs_div:
+            body = abs_div.find("div", class_="card-body")
+            if body:
+                abstract = body.get_text(strip=True)
+    
+    # Determine volume from paper_id
+    volume = ""
+    if paper_id:
+        parts = paper_id.split(".")
+        if len(parts) >= 2:
+            volume = parts[1]  # e.g., "acl-long" from "2023.acl-long.19"
+    
+    return {
+        "paper_id": paper_id,
+        "title": title,
+        "authors": authors,
+        "abstract": abstract,
+        "url": url,
+        "pdf_url": pdf_url,
+        "bib_url": bib_url,
+    }
+
+
+def main():
+    for year in range(4, 25):
+        year = f"20{year:02d}"
+        try:
+            html = fetch_page(SOURCE_URL.format(year=year))
+            print("Parsing ...", flush=True)
+            papers = parse_papers(html)
+            
+            print(f"Found {len(papers)} papers. Writing to {OUTPUT_FILE.format(year=year)} ...", flush=True)
+            with open(OUTPUT_FILE.format(year=year), "w", encoding="utf-8") as f:
+                for p in papers:
+                    f.write(json.dumps(p, ensure_ascii=False) + "\n")
+            
+            print("Done")
+        except Exception as e:
+            print(f"Error: {e}")
+
+
+if __name__ == "__main__":
+    main()

scripts/iwslt/iwslt2025.py

@@ -0,0 +1,122 @@
+import json
+import requests
+from bs4 import BeautifulSoup
+
+SOURCE_URL = "https://aclanthology.org/events/iwslt-2025/"
+OUTPUT_FILE = "data/iwslt/iwslt2025_papers.jsonl"
+BASE_URL    = "https://aclanthology.org"
+
+
+def fetch_page(url):
+    headers = {"User-Agent": "Mozilla/5.0 (ACL-parser/1.0; research)"}
+    print(f"Fetching {url} ...", flush=True)
+    resp = requests.get(url, headers=headers, timeout=120)
+    resp.raise_for_status()
+    return resp.text
+
+
+def abs_url(href):
+    if not href:
+        return ""
+    return href if href.startswith("http") else BASE_URL + href
+
+
+def parse_papers(html):
+    soup = BeautifulSoup(html, "html.parser")
+    papers = []
+
+    # Each volume section is wrapped in <div id="2025acl-long"> etc.
+    volume_divs = soup.find_all("div", id=lambda i: i and i.startswith("2025"))
+
+    for vol_div in volume_divs:
+        volume_id = vol_div.get("id", "")
+
+        # Volume name is in the <a class="align-middle"> inside the <h4>
+        h4 = vol_div.find("h4")
+        if h4:
+            vol_link = h4.find("a", class_="align-middle")
+            volume_name = vol_link.get_text(strip=True) if vol_link else h4.get_text(strip=True)
+        else:
+            volume_name = volume_id
+
+        # Each paper is a <div class="d-sm-flex align-items-stretch mb-3">
+        for card in vol_div.find_all("div", class_="d-sm-flex align-items-stretch mb-3"):
+            paper = parse_card(card, volume_id, volume_name)
+            if paper:
+                papers.append(paper)
+
+    return papers
+
+
+def parse_card(card, volume_id, volume_name):
+    # Title
+    strong = card.find("strong")
+    if not strong:
+        return None
+    title_link = strong.find("a")
+    if not title_link:
+        return None
+
+    title = title_link.get_text(strip=False)
+    href = title_link.get("href", "")
+    paper_id = href.strip("/")
+    url = abs_url(href)
+
+    # Skip front-matter entries (end with ".0")
+    if paper_id.endswith(".0"):
+        return None
+
+    # PDF / BIB from the button-row div
+    pdf_url = bib_url = ""
+    btn_row = card.find("div", class_="list-button-row")
+    if btn_row:
+        for a in btn_row.find_all("a", href=True):
+            text = a.get_text(strip=True).lower()
+            h    = a["href"]
+            if text == "pdf" or h.endswith(".pdf"):
+                pdf_url = abs_url(h)
+            elif text == "bib" or h.endswith(".bib"):
+                bib_url = abs_url(h)
+
+    # Authors: <a href="/people/..."> links inside the d-block span
+    authors = []
+    span = card.find("span", class_="d-block")
+    if span:
+        for a in span.find_all("a", href=True):
+            if "/people/" in a["href"]:
+                authors.append(a.get_text(strip=True))
+
+    # Abstract: next sibling div with class "abstract-collapse"
+    abstract = ""
+    nxt = card.find_next_sibling()
+    if nxt and "abstract-collapse" in nxt.get("class", []):
+        body = nxt.find("div", class_="card-body")
+        if body:
+            abstract = body.get_text(strip=True)
+
+    return {
+        "paper_id":  paper_id,
+        "title":     title,
+        "authors":   authors,
+        "abstract":  abstract,
+        "url":       url,
+        "pdf_url":   pdf_url,
+        "bib_url":   bib_url,
+    }
+
+
+def main():
+    html = fetch_page(SOURCE_URL)
+    print("Parsing ...", flush=True)
+    papers = parse_papers(html)
+
+    print(f"Found {len(papers)} papers. Writing to {OUTPUT_FILE} ...", flush=True)
+    with open(OUTPUT_FILE, "w", encoding="utf-8") as f:
+        for p in papers:
+            f.write(json.dumps(p, ensure_ascii=False) + "\n")
+
+    print("Done")
+
+
+if __name__ == "__main__":
+    main()

scripts/lrec/lrec.py

@@ -0,0 +1,128 @@
+import json
+import requests
+from bs4 import BeautifulSoup
+
+SOURCE_URL = "https://aclanthology.org/events/lrec-{year}/"
+OUTPUT_FILE = "data/lrec/lrec{year}_papers.jsonl"
+BASE_URL = "https://aclanthology.org"
+
+
+def fetch_page(url):
+    headers = {"User-Agent": "Mozilla/5.0 (ACL-parser/1.0; research)"}
+    print(f"Fetching {url} ...", flush=True)
+    resp = requests.get(url, headers=headers, timeout=120)
+    resp.raise_for_status()
+    return resp.text
+
+
+def abs_url(href):
+    if not href:
+        return ""
+    return href if href.startswith("http") else BASE_URL + href
+
+
+def parse_papers(html):
+    soup = BeautifulSoup(html, "html.parser")
+    papers = []
+    
+    # Find all paper divs - each paper is in a div with class "d-sm-flex align-items-stretch mb-3"
+    paper_divs = soup.find_all("div", class_="d-sm-flex align-items-stretch mb-3")
+    
+    for paper_div in paper_divs:
+        paper = parse_paper_div(paper_div)
+        if paper:
+            papers.append(paper)
+    
+    return papers
+
+
+def parse_paper_div(paper_div):
+    # Extract the paper title and URL
+    title_element = paper_div.find("strong")
+    if not title_element:
+        return None
+    
+    title_link = title_element.find("a")
+    if not title_link:
+        return None
+    
+    title = title_link.get_text(strip=False)
+    href = title_link.get("href", "")
+    paper_id = href.strip("/").split("/")[-1] if href else ""
+    url = abs_url(href)
+    
+    # Skip if no paper_id found
+    if not paper_id:
+        return None
+    
+    # PDF / BIB links from the button-row div
+    pdf_url = bib_url = ""
+    btn_row = paper_div.find("div", class_="list-button-row")
+    if btn_row:
+        for a in btn_row.find_all("a", href=True):
+            text = a.get_text(strip=True).lower()
+            h = a["href"]
+            if text == "pdf" or h.endswith(".pdf"):
+                pdf_url = abs_url(h)
+            elif text == "bib" or h.endswith(".bib"):
+                bib_url = abs_url(h)
+    
+    # Authors: <a href="/people/..."> links inside the d-block span
+    authors = []
+    span = paper_div.find("span", class_="d-block")
+    if span:
+        for a in span.find_all("a", href=True):
+            if "/people/" in a["href"]:
+                authors.append(a.get_text(strip=True))
+    
+    # Abstract: look for the collapse div with abstract content
+    abstract = ""
+    # Find the abstract ID from the button
+    abs_button = paper_div.find("a", class_="badge text-bg-info")
+    if abs_button and "data-bs-target" in abs_button.attrs:
+        abs_id = abs_button["data-bs-target"].lstrip("#")
+        # Find the abstract div using this ID
+        abs_div = soup.find("div", id=abs_id)
+        if abs_div:
+            body = abs_div.find("div", class_="card-body")
+            if body:
+                abstract = body.get_text(strip=True)
+    
+    # Determine volume from paper_id
+    volume = ""
+    if paper_id:
+        parts = paper_id.split(".")
+        if len(parts) >= 2:
+            volume = parts[1]  # e.g., "acl-long" from "2023.acl-long.19"
+    
+    return {
+        "paper_id": paper_id,
+        "title": title,
+        "authors": authors,
+        "abstract": abstract,
+        "url": url,
+        "pdf_url": pdf_url,
+        "bib_url": bib_url,
+    }
+
+
+def main():
+    for year in range(0, 25, 2):
+        year = f"20{year:02d}"
+        try:
+            html = fetch_page(SOURCE_URL.format(year=year))
+            print("Parsing ...", flush=True)
+            papers = parse_papers(html)
+            
+            print(f"Found {len(papers)} papers. Writing to {OUTPUT_FILE.format(year=year)} ...", flush=True)
+            with open(OUTPUT_FILE.format(year=year), "w", encoding="utf-8") as f:
+                for p in papers:
+                    f.write(json.dumps(p, ensure_ascii=False) + "\n")
+            
+            print("Done")
+        except Exception as e:
+            print(f"Error: {e}")
+
+
+if __name__ == "__main__":
+    main()

scripts/naacl/naacl.py

@@ -0,0 +1,130 @@
+import json
+import requests
+from bs4 import BeautifulSoup
+
+SOURCE_URL = "https://aclanthology.org/events/naacl-{year}/"
+OUTPUT_FILE = "data/naacl/naacl{year}_papers.jsonl"
+BASE_URL = "https://aclanthology.org"
+
+
+def fetch_page(url):
+    headers = {"User-Agent": "Mozilla/5.0 (ACL-parser/1.0; research)"}
+    print(f"Fetching {url} ...", flush=True)
+    resp = requests.get(url, headers=headers, timeout=120)
+    resp.raise_for_status()
+    # with open("acl.txt", "w") as f:
+    #     f.write(resp.text)
+    return resp.text
+
+
+def abs_url(href):
+    if not href:
+        return ""
+    return href if href.startswith("http") else BASE_URL + href
+
+
+def parse_papers(html):
+    soup = BeautifulSoup(html, "html.parser")
+    papers = []
+    
+    # Find all paper divs - each paper is in a div with class "d-sm-flex align-items-stretch mb-3"
+    paper_divs = soup.find_all("div", class_="d-sm-flex align-items-stretch mb-3")
+    
+    for paper_div in paper_divs:
+        paper = parse_paper_div(paper_div)
+        if paper:
+            papers.append(paper)
+    
+    return papers
+
+
+def parse_paper_div(paper_div):
+    # Extract the paper title and URL
+    title_element = paper_div.find("strong")
+    if not title_element:
+        return None
+    
+    title_link = title_element.find("a")
+    if not title_link:
+        return None
+    
+    title = title_link.get_text(strip=False)
+    href = title_link.get("href", "")
+    paper_id = href.strip("/").split("/")[-1] if href else ""
+    url = abs_url(href)
+    
+    # Skip if no paper_id found
+    if not paper_id:
+        return None
+    
+    # PDF / BIB links from the button-row div
+    pdf_url = bib_url = ""
+    btn_row = paper_div.find("div", class_="list-button-row")
+    if btn_row:
+        for a in btn_row.find_all("a", href=True):
+            text = a.get_text(strip=True).lower()
+            h = a["href"]
+            if text == "pdf" or h.endswith(".pdf"):
+                pdf_url = abs_url(h)
+            elif text == "bib" or h.endswith(".bib"):
+                bib_url = abs_url(h)
+    
+    # Authors: <a href="/people/..."> links inside the d-block span
+    authors = []
+    span = paper_div.find("span", class_="d-block")
+    if span:
+        for a in span.find_all("a", href=True):
+            if "/people/" in a["href"]:
+                authors.append(a.get_text(strip=True))
+    
+    # Abstract: look for the collapse div with abstract content
+    abstract = ""
+    # Find the abstract ID from the button
+    abs_button = paper_div.find("a", class_="badge text-bg-info")
+    if abs_button and "data-bs-target" in abs_button.attrs:
+        abs_id = abs_button["data-bs-target"].lstrip("#")
+        # Find the abstract div using this ID
+        abs_div = soup.find("div", id=abs_id)
+        if abs_div:
+            body = abs_div.find("div", class_="card-body")
+            if body:
+                abstract = body.get_text(strip=True)
+    
+    # Determine volume from paper_id
+    volume = ""
+    if paper_id:
+        parts = paper_id.split(".")
+        if len(parts) >= 2:
+            volume = parts[1]  # e.g., "acl-long" from "2023.acl-long.19"
+    
+    return {
+        "paper_id": paper_id,
+        "title": title,
+        "authors": authors,
+        "abstract": abstract,
+        "url": url,
+        "pdf_url": pdf_url,
+        "bib_url": bib_url,
+    }
+
+
+def main():
+    for year in [25, 24, 22, 21, 19, 18, 16, 15, 13, 12, 10, 9, 7, 6, 4, 3, 1, 0]:
+        year = f"20{year:02d}"
+        try:
+            html = fetch_page(SOURCE_URL.format(year=year))
+            print("Parsing ...", flush=True)
+            papers = parse_papers(html)
+            
+            print(f"Found {len(papers)} papers. Writing to {OUTPUT_FILE.format(year=year)} ...", flush=True)
+            with open(OUTPUT_FILE.format(year=year), "w", encoding="utf-8") as f:
+                for p in papers:
+                    f.write(json.dumps(p, ensure_ascii=False) + "\n")
+            
+            print("Done")
+        except Exception as e:
+            print(f"Error: {e}")
+
+
+if __name__ == "__main__":
+    main()

scripts/naacl/naacl2025.py

@@ -0,0 +1,122 @@
+import json
+import requests
+from bs4 import BeautifulSoup
+
+SOURCE_URL = "https://aclanthology.org/events/naacl-2025/"
+OUTPUT_FILE = "data/naacl/naacl2025_papers.jsonl"
+BASE_URL    = "https://aclanthology.org"
+
+
+def fetch_page(url):
+    headers = {"User-Agent": "Mozilla/5.0 (ACL-parser/1.0; research)"}
+    print(f"Fetching {url} ...", flush=True)
+    resp = requests.get(url, headers=headers, timeout=120)
+    resp.raise_for_status()
+    return resp.text
+
+
+def abs_url(href):
+    if not href:
+        return ""
+    return href if href.startswith("http") else BASE_URL + href
+
+
+def parse_papers(html):
+    soup = BeautifulSoup(html, "html.parser")
+    papers = []
+
+    # Each volume section is wrapped in <div id="2025acl-long"> etc.
+    volume_divs = soup.find_all("div", id=lambda i: i and i.startswith("2025"))
+
+    for vol_div in volume_divs:
+        volume_id = vol_div.get("id", "")
+
+        # Volume name is in the <a class="align-middle"> inside the <h4>
+        h4 = vol_div.find("h4")
+        if h4:
+            vol_link = h4.find("a", class_="align-middle")
+            volume_name = vol_link.get_text(strip=True) if vol_link else h4.get_text(strip=True)
+        else:
+            volume_name = volume_id
+
+        # Each paper is a <div class="d-sm-flex align-items-stretch mb-3">
+        for card in vol_div.find_all("div", class_="d-sm-flex align-items-stretch mb-3"):
+            paper = parse_card(card, volume_id, volume_name)
+            if paper:
+                papers.append(paper)
+
+    return papers
+
+
+def parse_card(card, volume_id, volume_name):
+    # Title
+    strong = card.find("strong")
+    if not strong:
+        return None
+    title_link = strong.find("a")
+    if not title_link:
+        return None
+
+    title = title_link.get_text(strip=False)
+    href = title_link.get("href", "")
+    paper_id = href.strip("/")
+    url = abs_url(href)
+
+    # Skip front-matter entries (end with ".0")
+    if paper_id.endswith(".0"):
+        return None
+
+    # PDF / BIB from the button-row div
+    pdf_url = bib_url = ""
+    btn_row = card.find("div", class_="list-button-row")
+    if btn_row:
+        for a in btn_row.find_all("a", href=True):
+            text = a.get_text(strip=True).lower()
+            h    = a["href"]
+            if text == "pdf" or h.endswith(".pdf"):
+                pdf_url = abs_url(h)
+            elif text == "bib" or h.endswith(".bib"):
+                bib_url = abs_url(h)
+
+    # Authors: <a href="/people/..."> links inside the d-block span
+    authors = []
+    span = card.find("span", class_="d-block")
+    if span:
+        for a in span.find_all("a", href=True):
+            if "/people/" in a["href"]:
+                authors.append(a.get_text(strip=True))
+
+    # Abstract: next sibling div with class "abstract-collapse"
+    abstract = ""
+    nxt = card.find_next_sibling()
+    if nxt and "abstract-collapse" in nxt.get("class", []):
+        body = nxt.find("div", class_="card-body")
+        if body:
+            abstract = body.get_text(strip=True)
+
+    return {
+        "paper_id":  paper_id,
+        "title":     title,
+        "authors":   authors,
+        "abstract":  abstract,
+        "url":       url,
+        "pdf_url":   pdf_url,
+        "bib_url":   bib_url,
+    }
+
+
+def main():
+    html = fetch_page(SOURCE_URL)
+    print("Parsing ...", flush=True)
+    papers = parse_papers(html)
+
+    print(f"Found {len(papers)} papers. Writing to {OUTPUT_FILE} ...", flush=True)
+    with open(OUTPUT_FILE, "w", encoding="utf-8") as f:
+        for p in papers:
+            f.write(json.dumps(p, ensure_ascii=False) + "\n")
+
+    print("Done")
+
+
+if __name__ == "__main__":
+    main()

scripts/rocling/rocling.py

@@ -0,0 +1,128 @@
+import json
+import requests
+from bs4 import BeautifulSoup
+
+SOURCE_URL = "https://aclanthology.org/events/rocling-{year}/"
+OUTPUT_FILE = "data/rocling/rocling{year}_papers.jsonl"
+BASE_URL = "https://aclanthology.org"
+
+
+def fetch_page(url):
+    headers = {"User-Agent": "Mozilla/5.0 (ACL-parser/1.0; research)"}
+    print(f"Fetching {url} ...", flush=True)
+    resp = requests.get(url, headers=headers, timeout=120)
+    resp.raise_for_status()
+    return resp.text
+
+
+def abs_url(href):
+    if not href:
+        return ""
+    return href if href.startswith("http") else BASE_URL + href
+
+
+def parse_papers(html):
+    soup = BeautifulSoup(html, "html.parser")
+    papers = []
+    
+    # Find all paper divs - each paper is in a div with class "d-sm-flex align-items-stretch mb-3"
+    paper_divs = soup.find_all("div", class_="d-sm-flex align-items-stretch mb-3")
+    
+    for paper_div in paper_divs:
+        paper = parse_paper_div(paper_div)
+        if paper:
+            papers.append(paper)
+    
+    return papers
+
+
+def parse_paper_div(paper_div):
+    # Extract the paper title and URL
+    title_element = paper_div.find("strong")
+    if not title_element:
+        return None
+    
+    title_link = title_element.find("a")
+    if not title_link:
+        return None
+    
+    title = title_link.get_text(strip=False)
+    href = title_link.get("href", "")
+    paper_id = href.strip("/").split("/")[-1] if href else ""
+    url = abs_url(href)
+    
+    # Skip if no paper_id found
+    if not paper_id:
+        return None
+    
+    # PDF / BIB links from the button-row div
+    pdf_url = bib_url = ""
+    btn_row = paper_div.find("div", class_="list-button-row")
+    if btn_row:
+        for a in btn_row.find_all("a", href=True):
+            text = a.get_text(strip=True).lower()
+            h = a["href"]
+            if text == "pdf" or h.endswith(".pdf"):
+                pdf_url = abs_url(h)
+            elif text == "bib" or h.endswith(".bib"):
+                bib_url = abs_url(h)
+    
+    # Authors: <a href="/people/..."> links inside the d-block span
+    authors = []
+    span = paper_div.find("span", class_="d-block")
+    if span:
+        for a in span.find_all("a", href=True):
+            if "/people/" in a["href"]:
+                authors.append(a.get_text(strip=True))
+    
+    # Abstract: look for the collapse div with abstract content
+    abstract = ""
+    # Find the abstract ID from the button
+    abs_button = paper_div.find("a", class_="badge text-bg-info")
+    if abs_button and "data-bs-target" in abs_button.attrs:
+        abs_id = abs_button["data-bs-target"].lstrip("#")
+        # Find the abstract div using this ID
+        abs_div = soup.find("div", id=abs_id)
+        if abs_div:
+            body = abs_div.find("div", class_="card-body")
+            if body:
+                abstract = body.get_text(strip=True)
+    
+    # Determine volume from paper_id
+    volume = ""
+    if paper_id:
+        parts = paper_id.split(".")
+        if len(parts) >= 2:
+            volume = parts[1]  # e.g., "acl-long" from "2023.acl-long.19"
+    
+    return {
+        "paper_id": paper_id,
+        "title": title,
+        "authors": authors,
+        "abstract": abstract,
+        "url": url,
+        "pdf_url": pdf_url,
+        "bib_url": bib_url,
+    }
+
+
+def main():
+    for year in range(3, 25):
+        year = f"20{year:02d}"
+        try:
+            html = fetch_page(SOURCE_URL.format(year=year))
+            print("Parsing ...", flush=True)
+            papers = parse_papers(html)
+            
+            print(f"Found {len(papers)} papers. Writing to {OUTPUT_FILE.format(year=year)} ...", flush=True)
+            with open(OUTPUT_FILE.format(year=year), "w", encoding="utf-8") as f:
+                for p in papers:
+                    f.write(json.dumps(p, ensure_ascii=False) + "\n")
+            
+            print("Done")
+        except Exception as e:
+            print(f"Error: {e}")
+
+
+if __name__ == "__main__":
+    main()

scripts/rocling/rocling2025.py

@@ -0,0 +1,122 @@
+import json
+import requests
+from bs4 import BeautifulSoup
+
+SOURCE_URL = "https://aclanthology.org/events/rocling-2025/"
+OUTPUT_FILE = "data/rocling/rocling2025_papers.jsonl"
+BASE_URL    = "https://aclanthology.org"
+
+
+def fetch_page(url):
+    headers = {"User-Agent": "Mozilla/5.0 (ACL-parser/1.0; research)"}
+    print(f"Fetching {url} ...", flush=True)
+    resp = requests.get(url, headers=headers, timeout=120)
+    resp.raise_for_status()
+    return resp.text
+
+
+def abs_url(href):
+    if not href:
+        return ""
+    return href if href.startswith("http") else BASE_URL + href
+
+
+def parse_papers(html):
+    soup = BeautifulSoup(html, "html.parser")
+    papers = []
+
+    # Each volume section is wrapped in <div id="2025acl-long"> etc.
+    volume_divs = soup.find_all("div", id=lambda i: i and i.startswith("2025"))
+
+    for vol_div in volume_divs:
+        volume_id = vol_div.get("id", "")
+
+        # Volume name is in the <a class="align-middle"> inside the <h4>
+        h4 = vol_div.find("h4")
+        if h4:
+            vol_link = h4.find("a", class_="align-middle")
+            volume_name = vol_link.get_text(strip=True) if vol_link else h4.get_text(strip=True)
+        else:
+            volume_name = volume_id
+
+        # Each paper is a <div class="d-sm-flex align-items-stretch mb-3">
+        for card in vol_div.find_all("div", class_="d-sm-flex align-items-stretch mb-3"):
+            paper = parse_card(card, volume_id, volume_name)
+            if paper:
+                papers.append(paper)
+
+    return papers
+
+
+def parse_card(card, volume_id, volume_name):
+    # Title
+    strong = card.find("strong")
+    if not strong:
+        return None
+    title_link = strong.find("a")
+    if not title_link:
+        return None
+
+    title = title_link.get_text(strip=False)
+    href = title_link.get("href", "")
+    paper_id = href.strip("/")
+    url = abs_url(href)
+
+    # Skip front-matter entries (end with ".0")
+    if paper_id.endswith(".0"):
+        return None
+
+    # PDF / BIB from the button-row div
+    pdf_url = bib_url = ""
+    btn_row = card.find("div", class_="list-button-row")
+    if btn_row:
+        for a in btn_row.find_all("a", href=True):
+            text = a.get_text(strip=True).lower()
+            h    = a["href"]
+            if text == "pdf" or h.endswith(".pdf"):
+                pdf_url = abs_url(h)
+            elif text == "bib" or h.endswith(".bib"):
+                bib_url = abs_url(h)
+
+    # Authors: <a href="/people/..."> links inside the d-block span
+    authors = []
+    span = card.find("span", class_="d-block")
+    if span:
+        for a in span.find_all("a", href=True):
+            if "/people/" in a["href"]:
+                authors.append(a.get_text(strip=True))
+
+    # Abstract: next sibling div with class "abstract-collapse"
+    abstract = ""
+    nxt = card.find_next_sibling()
+    if nxt and "abstract-collapse" in nxt.get("class", []):
+        body = nxt.find("div", class_="card-body")
+        if body:
+            abstract = body.get_text(strip=True)
+
+    return {
+        "paper_id":  paper_id,
+        "title":     title,
+        "authors":   authors,
+        "abstract":  abstract,
+        "url":       url,
+        "pdf_url":   pdf_url,
+        "bib_url":   bib_url,
+    }
+
+
+def main():
+    html = fetch_page(SOURCE_URL)
+    print("Parsing ...", flush=True)
+    papers = parse_papers(html)
+
+    print(f"Found {len(papers)} papers. Writing to {OUTPUT_FILE} ...", flush=True)
+    with open(OUTPUT_FILE, "w", encoding="utf-8") as f:
+        for p in papers:
+            f.write(json.dumps(p, ensure_ascii=False) + "\n")
+
+    print("Done")
+
+
+if __name__ == "__main__":
+    main()

scripts/semeval/semeval.py

@@ -0,0 +1,128 @@
+import json
+import requests
+from bs4 import BeautifulSoup
+
+SOURCE_URL = "https://aclanthology.org/events/semeval-{year}/"
+OUTPUT_FILE = "data/semeval/semeval{year}_papers.jsonl"
+BASE_URL = "https://aclanthology.org"
+
+
+def fetch_page(url):
+    headers = {"User-Agent": "Mozilla/5.0 (ACL-parser/1.0; research)"}
+    print(f"Fetching {url} ...", flush=True)
+    resp = requests.get(url, headers=headers, timeout=120)
+    resp.raise_for_status()
+    return resp.text
+
+
+def abs_url(href):
+    if not href:
+        return ""
+    return href if href.startswith("http") else BASE_URL + href
+
+
+def parse_papers(html):
+    soup = BeautifulSoup(html, "html.parser")
+    papers = []
+    
+    # Find all paper divs - each paper is in a div with class "d-sm-flex align-items-stretch mb-3"
+    paper_divs = soup.find_all("div", class_="d-sm-flex align-items-stretch mb-3")
+    
+    for paper_div in paper_divs:
+        paper = parse_paper_div(paper_div)
+        if paper:
+            papers.append(paper)
+    
+    return papers
+
+
+def parse_paper_div(paper_div):
+    # Extract the paper title and URL
+    title_element = paper_div.find("strong")
+    if not title_element:
+        return None
+    
+    title_link = title_element.find("a")
+    if not title_link:
+        return None
+    
+    title = title_link.get_text(strip=False)
+    href = title_link.get("href", "")
+    paper_id = href.strip("/").split("/")[-1] if href else ""
+    url = abs_url(href)
+    
+    # Skip if no paper_id found
+    if not paper_id:
+        return None
+    
+    # PDF / BIB links from the button-row div
+    pdf_url = bib_url = ""
+    btn_row = paper_div.find("div", class_="list-button-row")
+    if btn_row:
+        for a in btn_row.find_all("a", href=True):
+            text = a.get_text(strip=True).lower()
+            h = a["href"]
+            if text == "pdf" or h.endswith(".pdf"):
+                pdf_url = abs_url(h)
+            elif text == "bib" or h.endswith(".bib"):
+                bib_url = abs_url(h)
+    
+    # Authors: <a href="/people/..."> links inside the d-block span
+    authors = []
+    span = paper_div.find("span", class_="d-block")
+    if span:
+        for a in span.find_all("a", href=True):
+            if "/people/" in a["href"]:
+                authors.append(a.get_text(strip=True))
+    
+    # Abstract: look for the collapse div with abstract content
+    abstract = ""
+    # Find the abstract ID from the button
+    abs_button = paper_div.find("a", class_="badge text-bg-info")
+    if abs_button and "data-bs-target" in abs_button.attrs:
+        abs_id = abs_button["data-bs-target"].lstrip("#")
+        # Find the abstract div using this ID
+        abs_div = soup.find("div", id=abs_id)
+        if abs_div:
+            body = abs_div.find("div", class_="card-body")
+            if body:
+                abstract = body.get_text(strip=True)
+    
+    # Determine volume from paper_id
+    volume = ""
+    if paper_id:
+        parts = paper_id.split(".")
+        if len(parts) >= 2:
+            volume = parts[1]  # e.g., "acl-long" from "2023.acl-long.19"
+    
+    return {
+        "paper_id": paper_id,
+        "title": title,
+        "authors": authors,
+        "abstract": abstract,
+        "url": url,
+        "pdf_url": pdf_url,
+        "bib_url": bib_url,
+    }
+
+
+def main():
+    for year in list(range(12, 25)) + [1, 4, 7, 10]:
+        year = f"20{year:02d}"
+        try:
+            html = fetch_page(SOURCE_URL.format(year=year))
+            print("Parsing ...", flush=True)
+            papers = parse_papers(html)
+            
+            print(f"Found {len(papers)} papers. Writing to {OUTPUT_FILE.format(year=year)} ...", flush=True)
+            with open(OUTPUT_FILE.format(year=year), "w", encoding="utf-8") as f:
+                for p in papers:
+                    f.write(json.dumps(p, ensure_ascii=False) + "\n")
+            
+            print("Done")
+        except Exception as e:
+            print(f"Error: {e}")
+
+
+if __name__ == "__main__":
+    main()

scripts/semeval/semeval2025.py

@@ -0,0 +1,122 @@
+import json
+import requests
+from bs4 import BeautifulSoup
+
+SOURCE_URL = "https://aclanthology.org/events/semeval-2025/"
+OUTPUT_FILE = "data/semeval/semeval2025_papers.jsonl"
+BASE_URL    = "https://aclanthology.org"
+
+
+def fetch_page(url):
+    headers = {"User-Agent": "Mozilla/5.0 (ACL-parser/1.0; research)"}
+    print(f"Fetching {url} ...", flush=True)
+    resp = requests.get(url, headers=headers, timeout=120)
+    resp.raise_for_status()
+    return resp.text
+
+
+def abs_url(href):
+    if not href:
+        return ""
+    return href if href.startswith("http") else BASE_URL + href
+
+
+def parse_papers(html):
+    soup = BeautifulSoup(html, "html.parser")
+    papers = []
+
+    # Each volume section is wrapped in <div id="2025acl-long"> etc.
+    volume_divs = soup.find_all("div", id=lambda i: i and i.startswith("2025"))
+
+    for vol_div in volume_divs:
+        volume_id = vol_div.get("id", "")
+
+        # Volume name is in the <a class="align-middle"> inside the <h4>
+        h4 = vol_div.find("h4")
+        if h4:
+            vol_link = h4.find("a", class_="align-middle")
+            volume_name = vol_link.get_text(strip=True) if vol_link else h4.get_text(strip=True)
+        else:
+            volume_name = volume_id
+
+        # Each paper is a <div class="d-sm-flex align-items-stretch mb-3">
+        for card in vol_div.find_all("div", class_="d-sm-flex align-items-stretch mb-3"):
+            paper = parse_card(card, volume_id, volume_name)
+            if paper:
+                papers.append(paper)
+
+    return papers
+
+
+def parse_card(card, volume_id, volume_name):
+    # Title
+    strong = card.find("strong")
+    if not strong:
+        return None
+    title_link = strong.find("a")
+    if not title_link:
+        return None
+
+    title = title_link.get_text(strip=False)
+    href = title_link.get("href", "")
+    paper_id = href.strip("/")
+    url = abs_url(href)
+
+    # Skip front-matter entries (end with ".0")
+    if paper_id.endswith(".0"):
+        return None
+
+    # PDF / BIB from the button-row div
+    pdf_url = bib_url = ""
+    btn_row = card.find("div", class_="list-button-row")
+    if btn_row:
+        for a in btn_row.find_all("a", href=True):
+            text = a.get_text(strip=True).lower()
+            h    = a["href"]
+            if text == "pdf" or h.endswith(".pdf"):
+                pdf_url = abs_url(h)
+            elif text == "bib" or h.endswith(".bib"):
+                bib_url = abs_url(h)
+
+    # Authors: <a href="/people/..."> links inside the d-block span
+    authors = []
+    span = card.find("span", class_="d-block")
+    if span:
+        for a in span.find_all("a", href=True):
+            if "/people/" in a["href"]:
+                authors.append(a.get_text(strip=True))
+
+    # Abstract: next sibling div with class "abstract-collapse"
+    abstract = ""
+    nxt = card.find_next_sibling()
+    if nxt and "abstract-collapse" in nxt.get("class", []):
+        body = nxt.find("div", class_="card-body")
+        if body:
+            abstract = body.get_text(strip=True)
+
+    return {
+        "paper_id":  paper_id,
+        "title":     title,
+        "authors":   authors,
+        "abstract":  abstract,
+        "url":       url,
+        "pdf_url":   pdf_url,
+        "bib_url":   bib_url,
+    }
+
+
+def main():
+    html = fetch_page(SOURCE_URL)
+    print("Parsing ...", flush=True)
+    papers = parse_papers(html)
+
+    print(f"Found {len(papers)} papers. Writing to {OUTPUT_FILE} ...", flush=True)
+    with open(OUTPUT_FILE, "w", encoding="utf-8") as f:
+        for p in papers:
+            f.write(json.dumps(p, ensure_ascii=False) + "\n")
+
+    print("Done")
+
+
+if __name__ == "__main__":
+    main()

scripts/tacl/tacl.py

@@ -0,0 +1,130 @@
+import json
+import requests
+from bs4 import BeautifulSoup
+
+SOURCE_URL = "https://aclanthology.org/events/tacl-{year}/"
+OUTPUT_FILE = "data/tacl/tacl{year}_papers.jsonl"
+BASE_URL = "https://aclanthology.org"
+
+
+def fetch_page(url):
+    headers = {"User-Agent": "Mozilla/5.0 (ACL-parser/1.0; research)"}
+    print(f"Fetching {url} ...", flush=True)
+    resp = requests.get(url, headers=headers, timeout=120)
+    resp.raise_for_status()
+    # with open("acl.txt", "w") as f:
+    #     f.write(resp.text)
+    return resp.text
+
+
+def abs_url(href):
+    if not href:
+        return ""
+    return href if href.startswith("http") else BASE_URL + href
+
+
+def parse_papers(html):
+    soup = BeautifulSoup(html, "html.parser")
+    papers = []
+    
+    # Find all paper divs - each paper is in a div with class "d-sm-flex align-items-stretch mb-3"
+    paper_divs = soup.find_all("div", class_="d-sm-flex align-items-stretch mb-3")
+    
+    for paper_div in paper_divs:
+        paper = parse_paper_div(paper_div)
+        if paper:
+            papers.append(paper)
+    
+    return papers
+
+
+def parse_paper_div(paper_div):
+    # Extract the paper title and URL
+    title_element = paper_div.find("strong")
+    if not title_element:
+        return None
+    
+    title_link = title_element.find("a")
+    if not title_link:
+        return None
+    
+    title = title_link.get_text(strip=False)
+    href = title_link.get("href", "")
+    paper_id = href.strip("/").split("/")[-1] if href else ""
+    url = abs_url(href)
+    
+    # Skip if no paper_id found
+    if not paper_id:
+        return None
+    
+    # PDF / BIB links from the button-row div
+    pdf_url = bib_url = ""
+    btn_row = paper_div.find("div", class_="list-button-row")
+    if btn_row:
+        for a in btn_row.find_all("a", href=True):
+            text = a.get_text(strip=True).lower()
+            h = a["href"]
+            if text == "pdf" or h.endswith(".pdf"):
+                pdf_url = abs_url(h)
+            elif text == "bib" or h.endswith(".bib"):
+                bib_url = abs_url(h)
+    
+    # Authors: <a href="/people/..."> links inside the d-block span
+    authors = []
+    span = paper_div.find("span", class_="d-block")
+    if span:
+        for a in span.find_all("a", href=True):
+            if "/people/" in a["href"]:
+                authors.append(a.get_text(strip=True))
+    
+    # Abstract: look for the collapse div with abstract content
+    abstract = ""
+    # Find the abstract ID from the button
+    abs_button = paper_div.find("a", class_="badge text-bg-info")
+    if abs_button and "data-bs-target" in abs_button.attrs:
+        abs_id = abs_button["data-bs-target"].lstrip("#")
+        # Find the abstract div using this ID
+        abs_div = soup.find("div", id=abs_id)
+        if abs_div:
+            body = abs_div.find("div", class_="card-body")
+            if body:
+                abstract = body.get_text(strip=True)
+    
+    # Determine volume from paper_id
+    volume = ""
+    if paper_id:
+        parts = paper_id.split(".")
+        if len(parts) >= 2:
+            volume = parts[1]  # e.g., "acl-long" from "2023.acl-long.19"
+    
+    return {
+        "paper_id": paper_id,
+        "title": title,
+        "authors": authors,
+        "abstract": abstract,
+        "url": url,
+        "pdf_url": pdf_url,
+        "bib_url": bib_url,
+    }
+
+
+def main():
+    for year in range(13, 25):
+        year = f"20{year:02d}"
+        try:
+            html = fetch_page(SOURCE_URL.format(year=year))
+            print("Parsing ...", flush=True)
+            papers = parse_papers(html)
+            
+            print(f"Found {len(papers)} papers. Writing to {OUTPUT_FILE.format(year=year)} ...", flush=True)
+            with open(OUTPUT_FILE.format(year=year), "w", encoding="utf-8") as f:
+                for p in papers:
+                    f.write(json.dumps(p, ensure_ascii=False) + "\n")
+            
+            print("Done")
+        except Exception as e:
+            print(f"Error: {e}")
+
+
+if __name__ == "__main__":
+    main()

scripts/tacl/tacl2025.py

@@ -0,0 +1,122 @@
+import json
+import requests
+from bs4 import BeautifulSoup
+
+SOURCE_URL = "https://aclanthology.org/events/tacl-2025/"
+OUTPUT_FILE = "data/tacl/tacl2025_papers.jsonl"
+BASE_URL    = "https://aclanthology.org"
+
+
+def fetch_page(url):
+    headers = {"User-Agent": "Mozilla/5.0 (ACL-parser/1.0; research)"}
+    print(f"Fetching {url} ...", flush=True)
+    resp = requests.get(url, headers=headers, timeout=120)
+    resp.raise_for_status()
+    return resp.text
+
+
+def abs_url(href):
+    if not href:
+        return ""
+    return href if href.startswith("http") else BASE_URL + href
+
+
+def parse_papers(html):
+    soup = BeautifulSoup(html, "html.parser")
+    papers = []
+
+    # Each volume section is wrapped in <div id="2025acl-long"> etc.
+    volume_divs = soup.find_all("div", id=lambda i: i and i.startswith("2025"))
+
+    for vol_div in volume_divs:
+        volume_id = vol_div.get("id", "")
+
+        # Volume name is in the <a class="align-middle"> inside the <h4>
+        h4 = vol_div.find("h4")
+        if h4:
+            vol_link = h4.find("a", class_="align-middle")
+            volume_name = vol_link.get_text(strip=True) if vol_link else h4.get_text(strip=True)
+        else:
+            volume_name = volume_id
+
+        # Each paper is a <div class="d-sm-flex align-items-stretch mb-3">
+        for card in vol_div.find_all("div", class_="d-sm-flex align-items-stretch mb-3"):
+            paper = parse_card(card, volume_id, volume_name)
+            if paper:
+                papers.append(paper)
+
+    return papers
+
+
+def parse_card(card, volume_id, volume_name):
+    # Title
+    strong = card.find("strong")
+    if not strong:
+        return None
+    title_link = strong.find("a")
+    if not title_link:
+        return None
+
+    title = title_link.get_text(strip=False)
+    href = title_link.get("href", "")
+    paper_id = href.strip("/")
+    url = abs_url(href)
+
+    # Skip front-matter entries (end with ".0")
+    if paper_id.endswith(".0"):
+        return None
+
+    # PDF / BIB from the button-row div
+    pdf_url = bib_url = ""
+    btn_row = card.find("div", class_="list-button-row")
+    if btn_row:
+        for a in btn_row.find_all("a", href=True):
+            text = a.get_text(strip=True).lower()
+            h    = a["href"]
+            if text == "pdf" or h.endswith(".pdf"):
+                pdf_url = abs_url(h)
+            elif text == "bib" or h.endswith(".bib"):
+                bib_url = abs_url(h)
+
+    # Authors: <a href="/people/..."> links inside the d-block span
+    authors = []
+    span = card.find("span", class_="d-block")
+    if span:
+        for a in span.find_all("a", href=True):
+            if "/people/" in a["href"]:
+                authors.append(a.get_text(strip=True))
+
+    # Abstract: next sibling div with class "abstract-collapse"
+    abstract = ""
+    nxt = card.find_next_sibling()
+    if nxt and "abstract-collapse" in nxt.get("class", []):
+        body = nxt.find("div", class_="card-body")
+        if body:
+            abstract = body.get_text(strip=True)
+
+    return {
+        "paper_id":  paper_id,
+        "title":     title,
+        "authors":   authors,
+        "abstract":  abstract,
+        "url":       url,
+        "pdf_url":   pdf_url,
+        "bib_url":   bib_url,
+    }
+
+
+def main():
+    html = fetch_page(SOURCE_URL)
+    print("Parsing ...", flush=True)
+    papers = parse_papers(html)
+
+    print(f"Found {len(papers)} papers. Writing to {OUTPUT_FILE} ...", flush=True)
+    with open(OUTPUT_FILE, "w", encoding="utf-8") as f:
+        for p in papers:
+            f.write(json.dumps(p, ensure_ascii=False) + "\n")
+
+    print("Done")
+
+
+if __name__ == "__main__":
+    main()

scripts/tacl/tacl2026.py

@@ -0,0 +1,122 @@
+import json
+import requests
+from bs4 import BeautifulSoup
+
+SOURCE_URL = "https://aclanthology.org/events/tacl-2026/"
+OUTPUT_FILE = "data/tacl/tacl2026_papers.jsonl"
+BASE_URL    = "https://aclanthology.org"
+
+
+def fetch_page(url):
+    headers = {"User-Agent": "Mozilla/5.0 (ACL-parser/1.0; research)"}
+    print(f"Fetching {url} ...", flush=True)
+    resp = requests.get(url, headers=headers, timeout=120)
+    resp.raise_for_status()
+    return resp.text
+
+
+def abs_url(href):
+    if not href:
+        return ""
+    return href if href.startswith("http") else BASE_URL + href
+
+
+def parse_papers(html):
+    soup = BeautifulSoup(html, "html.parser")
+    papers = []
+
+    # Each volume section is wrapped in <div id="2025acl-long"> etc.
+    volume_divs = soup.find_all("div", id=lambda i: i and i.startswith("2026"))
+
+    for vol_div in volume_divs:
+        volume_id = vol_div.get("id", "")
+
+        # Volume name is in the <a class="align-middle"> inside the <h4>
+        h4 = vol_div.find("h4")
+        if h4:
+            vol_link = h4.find("a", class_="align-middle")
+            volume_name = vol_link.get_text(strip=True) if vol_link else h4.get_text(strip=True)
+        else:
+            volume_name = volume_id
+
+        # Each paper is a <div class="d-sm-flex align-items-stretch mb-3">
+        for card in vol_div.find_all("div", class_="d-sm-flex align-items-stretch mb-3"):
+            paper = parse_card(card, volume_id, volume_name)
+            if paper:
+                papers.append(paper)
+
+    return papers
+
+
+def parse_card(card, volume_id, volume_name):
+    # Title
+    strong = card.find("strong")
+    if not strong:
+        return None
+    title_link = strong.find("a")
+    if not title_link:
+        return None
+
+    title = title_link.get_text(strip=False)
+    href = title_link.get("href", "")
+    paper_id = href.strip("/")
+    url = abs_url(href)
+
+    # Skip front-matter entries (end with ".0")
+    if paper_id.endswith(".0"):
+        return None
+
+    # PDF / BIB from the button-row div
+    pdf_url = bib_url = ""
+    btn_row = card.find("div", class_="list-button-row")
+    if btn_row:
+        for a in btn_row.find_all("a", href=True):
+            text = a.get_text(strip=True).lower()
+            h    = a["href"]
+            if text == "pdf" or h.endswith(".pdf"):
+                pdf_url = abs_url(h)
+            elif text == "bib" or h.endswith(".bib"):
+                bib_url = abs_url(h)
+
+    # Authors: <a href="/people/..."> links inside the d-block span
+    authors = []
+    span = card.find("span", class_="d-block")
+    if span:
+        for a in span.find_all("a", href=True):
+            if "/people/" in a["href"]:
+                authors.append(a.get_text(strip=True))
+
+    # Abstract: next sibling div with class "abstract-collapse"
+    abstract = ""
+    nxt = card.find_next_sibling()
+    if nxt and "abstract-collapse" in nxt.get("class", []):
+        body = nxt.find("div", class_="card-body")
+        if body:
+            abstract = body.get_text(strip=True)
+
+    return {
+        "paper_id":  paper_id,
+        "title":     title,
+        "authors":   authors,
+        "abstract":  abstract,
+        "url":       url,
+        "pdf_url":   pdf_url,
+        "bib_url":   bib_url,
+    }
+
+
+def main():
+    html = fetch_page(SOURCE_URL)
+    print("Parsing ...", flush=True)
+    papers = parse_papers(html)
+
+    print(f"Found {len(papers)} papers. Writing to {OUTPUT_FILE} ...", flush=True)
+    with open(OUTPUT_FILE, "w", encoding="utf-8") as f:
+        for p in papers:
+            f.write(json.dumps(p, ensure_ascii=False) + "\n")
+
+    print("Done")
+
+
+if __name__ == "__main__":
+    main()

scripts/wmt/wmt.py

@@ -0,0 +1,128 @@
+import json
+import requests
+from bs4 import BeautifulSoup
+
+SOURCE_URL = "https://aclanthology.org/events/wmt-{year}/"
+OUTPUT_FILE = "data/wmt/wmt{year}_papers.jsonl"
+BASE_URL = "https://aclanthology.org"
+
+
+def fetch_page(url):
+    headers = {"User-Agent": "Mozilla/5.0 (ACL-parser/1.0; research)"}
+    print(f"Fetching {url} ...", flush=True)
+    resp = requests.get(url, headers=headers, timeout=120)
+    resp.raise_for_status()
+    return resp.text
+
+
+def abs_url(href):
+    if not href:
+        return ""
+    return href if href.startswith("http") else BASE_URL + href
+
+
+def parse_papers(html):
+    soup = BeautifulSoup(html, "html.parser")
+    papers = []
+    
+    # Find all paper divs - each paper is in a div with class "d-sm-flex align-items-stretch mb-3"
+    paper_divs = soup.find_all("div", class_="d-sm-flex align-items-stretch mb-3")
+    
+    for paper_div in paper_divs:
+        paper = parse_paper_div(paper_div)
+        if paper:
+            papers.append(paper)
+    
+    return papers
+
+
+def parse_paper_div(paper_div):
+    # Extract the paper title and URL
+    title_element = paper_div.find("strong")
+    if not title_element:
+        return None
+    
+    title_link = title_element.find("a")
+    if not title_link:
+        return None
+    
+    title = title_link.get_text(strip=False)
+    href = title_link.get("href", "")
+    paper_id = href.strip("/").split("/")[-1] if href else ""
+    url = abs_url(href)
+    
+    # Skip if no paper_id found
+    if not paper_id:
+        return None
+    
+    # PDF / BIB links from the button-row div
+    pdf_url = bib_url = ""
+    btn_row = paper_div.find("div", class_="list-button-row")
+    if btn_row:
+        for a in btn_row.find_all("a", href=True):
+            text = a.get_text(strip=True).lower()
+            h = a["href"]
+            if text == "pdf" or h.endswith(".pdf"):
+                pdf_url = abs_url(h)
+            elif text == "bib" or h.endswith(".bib"):
+                bib_url = abs_url(h)
+    
+    # Authors: <a href="/people/..."> links inside the d-block span
+    authors = []
+    span = paper_div.find("span", class_="d-block")
+    if span:
+        for a in span.find_all("a", href=True):
+            if "/people/" in a["href"]:
+                authors.append(a.get_text(strip=True))
+    
+    # Abstract: look for the collapse div with abstract content
+    abstract = ""
+    # Find the abstract ID from the button
+    abs_button = paper_div.find("a", class_="badge text-bg-info")
+    if abs_button and "data-bs-target" in abs_button.attrs:
+        abs_id = abs_button["data-bs-target"].lstrip("#")
+        # Find the abstract div using this ID
+        abs_div = soup.find("div", id=abs_id)
+        if abs_div:
+            body = abs_div.find("div", class_="card-body")
+            if body:
+                abstract = body.get_text(strip=True)
+    
+    # Determine volume from paper_id
+    volume = ""
+    if paper_id:
+        parts = paper_id.split(".")
+        if len(parts) >= 2:
+            volume = parts[1]  # e.g., "acl-long" from "2023.acl-long.19"
+    
+    return {
+        "paper_id": paper_id,
+        "title": title,
+        "authors": authors,
+        "abstract": abstract,
+        "url": url,
+        "pdf_url": pdf_url,
+        "bib_url": bib_url,
+    }
+
+
+def main():
+    for year in range(6, 25):
+        year = f"20{year:02d}"
+        try:
+            html = fetch_page(SOURCE_URL.format(year=year))
+            print("Parsing ...", flush=True)
+            papers = parse_papers(html)
+            
+            print(f"Found {len(papers)} papers. Writing to {OUTPUT_FILE.format(year=year)} ...", flush=True)
+            with open(OUTPUT_FILE.format(year=year), "w", encoding="utf-8") as f:
+                for p in papers:
+                    f.write(json.dumps(p, ensure_ascii=False) + "\n")
+            
+            print("Done")
+        except Exception as e:
+            print(f"Error: {e}")
+
+
+if __name__ == "__main__":
+    main()

scripts/wmt/wmt2025.py

@@ -0,0 +1,122 @@
+import json
+import requests
+from bs4 import BeautifulSoup
+
+SOURCE_URL = "https://aclanthology.org/events/wmt-2025/"
+OUTPUT_FILE = "data/wmt/wmt2025_papers.jsonl"
+BASE_URL    = "https://aclanthology.org"
+
+
+def fetch_page(url):
+    headers = {"User-Agent": "Mozilla/5.0 (ACL-parser/1.0; research)"}
+    print(f"Fetching {url} ...", flush=True)
+    resp = requests.get(url, headers=headers, timeout=120)
+    resp.raise_for_status()
+    return resp.text
+
+
+def abs_url(href):
+    if not href:
+        return ""
+    return href if href.startswith("http") else BASE_URL + href
+
+
+def parse_papers(html):
+    soup = BeautifulSoup(html, "html.parser")
+    papers = []
+
+    # Each volume section is wrapped in <div id="2025acl-long"> etc.
+    volume_divs = soup.find_all("div", id=lambda i: i and i.startswith("2025"))
+
+    for vol_div in volume_divs:
+        volume_id = vol_div.get("id", "")
+
+        # Volume name is in the <a class="align-middle"> inside the <h4>
+        h4 = vol_div.find("h4")
+        if h4:
+            vol_link = h4.find("a", class_="align-middle")
+            volume_name = vol_link.get_text(strip=True) if vol_link else h4.get_text(strip=True)
+        else:
+            volume_name = volume_id
+
+        # Each paper is a <div class="d-sm-flex align-items-stretch mb-3">
+        for card in vol_div.find_all("div", class_="d-sm-flex align-items-stretch mb-3"):
+            paper = parse_card(card, volume_id, volume_name)
+            if paper:
+                papers.append(paper)
+
+    return papers
+
+
+def parse_card(card, volume_id, volume_name):
+    # Title
+    strong = card.find("strong")
+    if not strong:
+        return None
+    title_link = strong.find("a")
+    if not title_link:
+        return None
+
+    title = title_link.get_text(strip=False)
+    href = title_link.get("href", "")
+    paper_id = href.strip("/")
+    url = abs_url(href)
+
+    # Skip front-matter entries (end with ".0")
+    if paper_id.endswith(".0"):
+        return None
+
+    # PDF / BIB from the button-row div
+    pdf_url = bib_url = ""
+    btn_row = card.find("div", class_="list-button-row")
+    if btn_row:
+        for a in btn_row.find_all("a", href=True):
+            text = a.get_text(strip=True).lower()
+            h    = a["href"]
+            if text == "pdf" or h.endswith(".pdf"):
+                pdf_url = abs_url(h)
+            elif text == "bib" or h.endswith(".bib"):
+                bib_url = abs_url(h)
+
+    # Authors: <a href="/people/..."> links inside the d-block span
+    authors = []
+    span = card.find("span", class_="d-block")
+    if span:
+        for a in span.find_all("a", href=True):
+            if "/people/" in a["href"]:
+                authors.append(a.get_text(strip=True))
+
+    # Abstract: next sibling div with class "abstract-collapse"
+    abstract = ""
+    nxt = card.find_next_sibling()
+    if nxt and "abstract-collapse" in nxt.get("class", []):
+        body = nxt.find("div", class_="card-body")
+        if body:
+            abstract = body.get_text(strip=True)
+
+    return {
+        "paper_id":  paper_id,
+        "title":     title,
+        "authors":   authors,
+        "abstract":  abstract,
+        "url":       url,
+        "pdf_url":   pdf_url,
+        "bib_url":   bib_url,
+    }
+
+
+def main():
+    html = fetch_page(SOURCE_URL)
+    print("Parsing ...", flush=True)
+    papers = parse_papers(html)
+
+    print(f"Found {len(papers)} papers. Writing to {OUTPUT_FILE} ...", flush=True)
+    with open(OUTPUT_FILE, "w", encoding="utf-8") as f:
+        for p in papers:
+            f.write(json.dumps(p, ensure_ascii=False) + "\n")
+
+    print("Done")
+
+
+if __name__ == "__main__":
+    main()