import json import requests import sys import os from datetime import datetime from dateutil.relativedelta import relativedelta import logging from multiprocessing import Pool, cpu_count from tqdm import tqdm import re import feedparser import time # Configuration Variables MONTHS_BACK = 99 # Default number of months back to download papers OUTPUT_DIR = 'arxiv_dumps' JSONL_FILE = 'downloaded_papers.jsonl' CACHE_DIR = 'cache' SEARCH_CACHE_FILE = os.path.join(CACHE_DIR, 'search_cache.jsonl') MAX_RESULTS_PER_PAGE = 100 MAX_BACKOFF = 120 # Maximum backoff time in seconds CONCURRENT_DOWNLOADS = min(32, cpu_count()) # Number of concurrent downloads def setup_logging(enable_logging: bool): if enable_logging: logging.basicConfig(filename='arxivdump.log', filemode='a', format='%(asctime)s - %(levelname)s - %(message)s', level=logging.DEBUG) else: logging.basicConfig(level=logging.CRITICAL) logging.disable(logging.CRITICAL) def sanitize_filename(name): return re.sub(r'[^\w\-]', '', name.replace(' ', '_')) def load_cache(file_path): if not os.path.exists(file_path): return set() with open(file_path, 'r', encoding='utf-8') as f: return set(json.loads(line).get('id') for line in f) def update_cache(file_path, metadata): os.makedirs(os.path.dirname(file_path), exist_ok=True) with open(file_path, 'a', encoding='utf-8') as f: f.write(json.dumps(metadata, ensure_ascii=False) + '\n') def fetch_paper_source(entry_id, headers): src_url = entry_id.replace("/abs/", "/src/").replace("https://arxiv.org/", "https://export.arxiv.org/") backoff = 1 while True: try: response = requests.get(src_url, headers=headers, allow_redirects=True, timeout=60) content_type = response.headers.get('Content-Type', '').lower() content_disposition = response.headers.get('Content-Disposition', '') if 'filename=' in content_disposition: filename = content_disposition.split('filename=')[-1].strip('"') else: filename = f"{entry_id.split('/')[-1]}.unlabeled_file_type" return (response.content, content_type, dict(response.headers), filename) except requests.exceptions.RequestException as e: logging.warning(f"Request failed for {entry_id}: {e}. Retrying in {backoff} seconds.") time.sleep(backoff) backoff = min(backoff * 2, MAX_BACKOFF) def save_archive_and_metadata(content, content_type, response_headers, filename, paper_title, index, jsonl_file, paper): sanitized_title = sanitize_filename(paper_title) paper_dir = os.path.join(OUTPUT_DIR, f"{index}_{sanitized_title}") os.makedirs(paper_dir, exist_ok=True) if content and filename: archive_path = os.path.join(paper_dir, filename) with open(archive_path, 'wb') as f: f.write(content) logging.info(f"Saved archive to: {archive_path}") else: logging.warning(f"No archive content to save for paper {index}_{sanitized_title}.") metadata = { "id": paper['id'], "title": paper['title'], "authors": [author['name'] for author in paper['authors']], "summary": paper['summary'], "categories": [tag['term'] for tag in paper['tags']], "published": paper['published'], "updated": paper['updated'], "links": paper['links'], "source_response_headers": response_headers, "downloaded_at": datetime.utcnow().isoformat() + 'Z' } metadata_path = os.path.join(paper_dir, 'metadata.json') with open(metadata_path, 'w', encoding='utf-8') as f: json.dump(metadata, f, ensure_ascii=False, indent=4) update_cache(jsonl_file, metadata) def cache_search_results(results): os.makedirs(CACHE_DIR, exist_ok=True) with open(SEARCH_CACHE_FILE, 'a', encoding='utf-8') as f: for paper in results: f.write(json.dumps({ 'id': paper['id'], 'title': paper['title'], 'published': paper['published'], 'updated': paper['updated'], 'summary': paper['summary'], 'authors': [author['name'] for author in paper['authors']], 'categories': [tag['term'] for tag in paper['tags']], 'links': paper['links'] }, ensure_ascii=False) + '\n') def parse_atom_feed(feed_content): parsed_feed = feedparser.parse(feed_content) results = [] for entry in parsed_feed.entries: links_dict = {link.get('title', link.get('rel', 'unknown')): link.get('href') for link in entry.links} results.append({ 'id': entry.id, 'title': entry.title, 'summary': entry.summary, 'published': entry.published, 'updated': entry.updated, 'tags': [{'term': tag.term} for tag in entry.get('tags', [])], 'authors': [{'name': author.name} for author in entry.authors], 'links': links_dict }) return results def process_paper(args): index, paper, headers, jsonl_file, cached_ids = args entry_id = paper['id'] paper_id = entry_id.split('/')[-1] if paper_id in cached_ids: return None try: content, content_type, response_headers, filename = fetch_paper_source(entry_id, headers) if content and content_type: save_archive_and_metadata(content, content_type, response_headers, filename, paper['title'], index, jsonl_file, paper) return paper['published'] except Exception as e: logging.error(f"Exception occurred while processing paper {paper_id}: {e}") return None def main(): setup_logging(True) # Always enable logging for now print(f"Starting arXiv paper download for the past {MONTHS_BACK} months") logging.info(f"Starting arXiv paper download for the past {MONTHS_BACK} months") query = "cat:cs.*" sort_by = "submittedDate" sort_order = "descending" print(f"Search query: {query} | sortBy={sort_by} | sortOrder={sort_order}") logging.info(f"Search query: {query} | sortBy={sort_by} | sortOrder={sort_order}") start = 0 papers = [] cutoff_date = datetime.now() - relativedelta(months=MONTHS_BACK) reached_cutoff = False while not reached_cutoff: search_url = f"http://export.arxiv.org/api/query?search_query={query}&sortBy={sort_by}&sortOrder={sort_order}&start={start}&max_results={MAX_RESULTS_PER_PAGE}" print(f"Fetching page starting from {start}: {search_url}") logging.info(f"Fetching page starting from {start}: {search_url}") response = requests.get(search_url) parsed_results = parse_atom_feed(response.content) if not parsed_results: break for paper in parsed_results: published_date = datetime.strptime(paper['published'], "%Y-%m-%dT%H:%M:%SZ") if published_date < cutoff_date: reached_cutoff = True break papers.append(paper) cache_search_results(parsed_results) start += len(parsed_results) if len(parsed_results) < MAX_RESULTS_PER_PAGE: break time.sleep(3) # Respectful delay between API calls headers = { "User-Agent": "Mozilla/5.0 (compatible; ArXivDownloader/1.0; +https://github.com/yourusername/arxiv-downloader)", "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8", "Accept-Language": "en-US,en;q=0.5", "Referer": "https://arxiv.org/", "Connection": "keep-alive", "Upgrade-Insecure-Requests": "1" } cached_ids = load_cache(JSONL_FILE) print(f"Starting to process {len(papers)} papers with multiprocessing...") logging.info(f"Starting to process {len(papers)} papers with multiprocessing.") os.makedirs(OUTPUT_DIR, exist_ok=True) args_list = [(index, paper, headers, JSONL_FILE, cached_ids) for index, paper in enumerate(papers, start=1)] with Pool(processes=CONCURRENT_DOWNLOADS) as pool: list(tqdm(pool.imap_unordered(process_paper, args_list), total=len(papers), desc="Downloading papers")) print("Processing complete.") logging.info("Processing complete.") if __name__ == "__main__": main()