| |
| """Validate the published collection without accessing the original library.""" |
| import csv |
| import os |
| import hashlib |
| import json |
| import re |
| import zipfile |
| import gzip |
| from paper_length_policy import short_paper_reason, excluded_publication_reason, acl2019_program_types, title_key |
| from collections import Counter |
| from datetime import datetime, timezone |
| from pathlib import Path |
| from urllib.parse import unquote, urlsplit |
| from xml.etree import ElementTree as ET |
|
|
| REPO = Path(__file__).resolve().parents[1] |
| TRACK = os.environ.get('AI4FINANCE_TRACK', 'main') |
| assert TRACK in {'main', 'findings'} |
| ROOT = REPO / TRACK |
|
|
|
|
| def read_csv(path): |
| with path.open(encoding='utf-8-sig', newline='') as stream: |
| return list(csv.DictReader(stream)) |
|
|
|
|
| def digest(path): |
| result = hashlib.sha256() |
| with path.open('rb') as stream: |
| for block in iter(lambda: stream.read(1024 * 1024), b''): |
| result.update(block) |
| return result.hexdigest() |
|
|
|
|
| def workbook_sheets(path): |
| ns = {'s': 'http://schemas.openxmlformats.org/spreadsheetml/2006/main'} |
| rel_ns = '{http://schemas.openxmlformats.org/officeDocument/2006/relationships}id' |
| with zipfile.ZipFile(path) as archive: |
| assert archive.testzip() is None, 'Corrupt Excel archive' |
| strings = [] |
| if 'xl/sharedStrings.xml' in archive.namelist(): |
| strings = [''.join(node.itertext()) for node in |
| ET.fromstring(archive.read('xl/sharedStrings.xml'))] |
| relationships = {node.attrib['Id']: node.attrib['Target'] for node in |
| ET.fromstring(archive.read('xl/_rels/workbook.xml.rels'))} |
| sheets = ET.fromstring(archive.read('xl/workbook.xml')).find('s:sheets', ns) |
| result = {} |
| for sheet in sheets: |
| target = relationships[sheet.attrib[rel_ns]] |
| target = target.lstrip('/') if target.startswith('/') else 'xl/' + target |
| data = ET.fromstring(archive.read(target)).find('s:sheetData', ns) |
| rows = [] |
| for row in data: |
| values = {} |
| for cell in row: |
| column = re.match(r'[A-Z]+', cell.attrib['r']).group() |
| if cell.attrib.get('t') == 'inlineStr': |
| inline = cell.find('s:is', ns) |
| value = ''.join(inline.itertext()) if inline is not None else '' |
| else: |
| value = cell.findtext('s:v', default='', namespaces=ns) |
| if cell.attrib.get('t') == 's': |
| value = strings[int(value)] |
| values[column] = value |
| rows.append(values) |
| result[sheet.attrib['name']] = rows |
| return result |
|
|
|
|
| def sheet_records(rows): |
| header = rows[0] |
| return [{name: row.get(column, '') for column, name in header.items()} for row in rows[1:]] |
|
|
|
|
| def main(): |
| rows = read_csv(ROOT / 'finance_catalog.csv') |
| ids = {row['id'] for row in rows} |
| assert len(ids) == len(rows), 'Duplicate paper IDs' |
| assert all(row['track'] == TRACK for row in rows), 'Mixed publication tracks in catalog' |
| assert all(row['venue'] in {'AAAI', 'ACL', 'EMNLP', 'ICLR', 'ICML', 'NeurIPS'} for row in rows) |
| assert all(2017 <= int(row['year']) <= 2026 for row in rows) |
| assert all(row['paper_length'] == 'long' for row in rows), 'Non-long paper admitted' |
| assert all(row['finance_scope'] in {'core', 'application'} for row in rows) |
| assert all(urlsplit(row['paper_url']).scheme in {'http', 'https'} |
| and urlsplit(row['paper_url']).netloc for row in rows) |
| assert len({row['paper_url'] for row in rows}) == len(rows), 'Duplicate official paper URL' |
| notes = {path.stem for path in (ROOT / 'indexes/finance_notes').glob('*.md')} |
| assert notes == ids, 'Paper note IDs do not match catalog' |
|
|
| records = [json.loads(line) for line in (ROOT / 'finance_catalog.jsonl').read_text().splitlines()] |
| assert len(records) == len(rows) and {r['id'] for r in records} == ids |
| structured = {r['id']: r for r in records} |
| official_2019 = acl2019_program_types(gzip.decompress( |
| (REPO/'checks/track_screening/length_sources/acl-2019-program-github.gz').read_bytes()).decode()) |
| schema = json.loads((ROOT / 'checks/finance_taxonomy/schema.json').read_text()) |
| assignments = json.loads((ROOT / 'checks/finance_taxonomy/assignments.json').read_text()) |
| assert set(assignments) == ids |
| definitions = {key: {item['id']: item for item in schema[key]} |
| for key in ('topics', 'subtopics', 'methods')} |
| pdf_paths = set() |
| total_bytes = 0 |
| for row in rows: |
| pid = row['id'] |
| record = structured[pid] |
| assert short_paper_reason(record) is None, (pid, short_paper_reason(record)) |
| assert excluded_publication_reason(record) is None, (pid, excluded_publication_reason(record)) |
| if record['venue']=='ACL' and int(record['year'])==2019: |
| assert official_2019.get(title_key(record['title']))=='long', (pid,'Not in official Main Long Papers program') |
| assert record['track'] == row['track'] == TRACK, pid |
| for field in ('title', 'venue', 'year', 'paper_url'): |
| assert str(record[field]) == row[field], (pid, field) |
| assert record['paper_length'] == 'long' and record['paper_length_evidence'], pid |
| finance = record['finance'] |
| assert finance['scope'] == row['finance_scope'], pid |
| assignment = assignments[pid] |
| |
| |
| assert row['finance_evidence_excerpt'].strip() or ( |
| row['finance_evidence_type'] == 'title_abstract_review' |
| and any(e.get('source') in {'title', 'abstract'} and e.get('excerpt', '').strip() |
| for e in assignment['topic_evidence']) |
| ), (pid, 'Missing inclusion evidence') |
| assert assignment['primary_topic_id'] in assignment['topic_ids'], pid |
| for field, category in [('topic_ids', 'topics'), ('subtopic_ids', 'subtopics'), |
| ('method_ids', 'methods')]: |
| assert len(assignment[field]) == len(set(assignment[field])), (pid, field) |
| assert set(assignment[field]) <= set(definitions[category]), (pid, field) |
| assert finance[field] == assignment[field], (pid, field) |
| assert all(definitions['subtopics'][sid]['parent_id'] in assignment['topic_ids'] |
| for sid in assignment['subtopic_ids']), pid |
| for column, field, category in [('finance_topics', 'topic_ids', 'topics'), |
| ('finance_subtopics', 'subtopic_ids', 'subtopics'), |
| ('finance_methods', 'method_ids', 'methods')]: |
| assert row[column] == '; '.join(definitions[category][i]['label'] |
| for i in assignment[field]), (pid, column) |
| assert row['finance_primary_topic'] == definitions['topics'][assignment['primary_topic_id']]['label'] |
| assert row['finance_topic_ids'].split('; ') == assignment['topic_ids'], pid |
| if row['download_status'] == 'downloaded': |
| relative = row['local_path'] |
| path = (ROOT / relative).resolve() |
| assert path.is_relative_to(ROOT / 'pdfs') and path.is_file(), relative |
| assert relative not in pdf_paths, 'Duplicate PDF path' |
| pdf_paths.add(relative) |
| assert path.stat().st_size == int(row['bytes']), relative |
| with path.open('rb') as stream: |
| assert stream.read(5) == b'%PDF-', relative |
| assert digest(path) == row['sha256'], relative |
| assert record['download']['local_path'] == relative, pid |
| total_bytes += path.stat().st_size |
| else: |
| assert not row['local_path'], pid |
| actual_pdfs = {str(path.relative_to(ROOT)) for path in (ROOT / 'pdfs').rglob('*.pdf')} |
| assert actual_pdfs == pdf_paths, 'Unexpected or missing PDF files' |
|
|
| sheets = workbook_sheets(ROOT / 'finance_catalog.xlsx') |
| all_sheet = sheet_records(sheets['Confirmed Finance']) |
| assert {row['id'] for row in all_sheet} == ids and len(all_sheet) == len(rows) |
| excel_rows = {row['id']: row for row in all_sheet} |
| for row in rows: |
| for column in ('title', 'venue', 'year', 'track', 'finance_scope', 'finance_primary_topic', |
| 'finance_topics', 'finance_subtopics', 'finance_methods', 'local_path', 'sha256'): |
| assert excel_rows[row['id']][column] == row[column], (row['id'], column, 'Excel') |
| for topic in schema['topics']: |
| subset = read_csv(ROOT / f"indexes/finance_topics/{topic['id']}.csv") |
| expected = {row['id'] for row in rows if topic['id'] in assignments[row['id']]['topic_ids']} |
| assert {row['id'] for row in subset} == expected and len(subset) == len(expected) |
| sheet = sheet_records(sheets[topic['sheet']]) |
| assert {row['id'] for row in sheet} == expected and len(sheet) == len(expected) |
| bibkeys = re.findall(r'^@\w+\{([^,]+),', (ROOT / 'finance_references.bib').read_text(), re.M) |
| assert len(bibkeys) == len(rows) and len(set(bibkeys)) == len(rows), 'BibTeX count/duplicates' |
| assert set(bibkeys) == {re.sub('[^A-Za-z0-9_-]', '_', pid) for pid in ids}, 'BibTeX identities differ' |
| missing_rows = read_csv(ROOT / 'checks/missing_pdfs.csv') |
| expected_missing = {row['id'] for row in rows if row['download_status'] != 'downloaded'} |
| assert {row['id'] for row in missing_rows} == expected_missing |
|
|
| links_checked = 0 |
| for path in ROOT.rglob('*.md'): |
| if '.git' in path.parts: |
| continue |
| for target in re.findall(r'\]\(([^)]+)\)', path.read_text()): |
| target = target.strip('<>') |
| parsed = urlsplit(target) |
| if parsed.scheme or parsed.netloc or not parsed.path: |
| continue |
| resolved = (path.parent / unquote(parsed.path)).resolve() |
| |
| report_target = ROOT / 'checks/validation.json' |
| assert resolved.is_relative_to(REPO) and (resolved.exists() or resolved == report_target), (str(path), target) |
| links_checked += 1 |
|
|
| report = { |
| 'validated_at_utc': datetime.now(timezone.utc).isoformat(), |
| 'papers': len(rows), 'tracks': dict(Counter(row['track'] for row in rows)), |
| 'scope': dict(Counter(row['finance_scope'] for row in rows)), |
| 'venues': dict(Counter(row['venue'] for row in rows)), |
| 'years': dict(sorted(Counter(row['year'] for row in rows).items())), |
| 'topics': len(schema['topics']), 'paper_notes': len(notes), |
| 'pdfs': len(pdf_paths), 'pdf_bytes': total_bytes, |
| 'missing_pdfs': len(missing_rows), 'local_markdown_links_checked': links_checked, |
| 'title_abstract_reviews_without_separate_inclusion_excerpt': [ |
| row['id'] for row in rows if not row['finance_evidence_excerpt'].strip()], |
| 'csv_jsonl_excel_classifications_consistent': True, |
| 'topic_memberships_consistent': True, 'bibtex_identities_consistent': True, |
| 'all_local_links_resolve': True, 'all_pdf_hashes_match': True, |
| 'separate_track_validated': TRACK, |
| 'explicit_short_paper_records': 0, |
| } |
| (ROOT / 'checks/validation.json').write_text(json.dumps(report, indent=2) + '\n') |
| print(json.dumps(report, indent=2)) |
|
|
|
|
| if __name__ == '__main__': |
| main() |
|
|
