| |
| """Derive an OpenAlex-wide queue from screened links and explicit collection mappings.""" |
| from __future__ import annotations |
| import argparse, collections, csv, datetime as dt, hashlib, io, json, os, re, tempfile |
| from pathlib import Path |
|
|
| ROOT = Path(__file__).resolve().parents[1] |
| CSV_PATH = 'planning/openalex_workqueue.csv' |
| SUMMARY_PATH = 'planning/workqueue_summary.json' |
| STATE_PATH = 'planning/workqueue_state.json' |
| QUEUE_FIELDS = ['priority','domain_id','domain_name','field_id','field_name','subfield_id','subfield_name','topic_count','valid_pdf_count','book_scope_pdf_count','verified_entry_count','distinct_pdf_url_count','collection_count','collection_ids','count_basis','availability','historical_round_status','completed_rounds','last_search_at','last_new_entries','last_new_pdfs','owner','lease_id','generation','lease_expires_at','cooldown_until','prompt_file'] |
| BOOK_TYPES = {'textbook','handbook','scholarly_book','edited_collection','book_chapter','doctoral_thesis','research_thesis','thesis_framing_text','habilitation_thesis','research_report'} |
|
|
| def read_jsonl(path): |
| return [json.loads(line) for line in Path(path).read_text().splitlines() if line.strip()] |
|
|
| def utc(value=None): |
| if value is None: return dt.datetime.now(dt.timezone.utc) |
| if isinstance(value,str): value=dt.datetime.fromisoformat(value.replace('Z','+00:00')) |
| if not isinstance(value,dt.datetime) or value.tzinfo is None or value.utcoffset()!=dt.timedelta(0): |
| raise ValueError('Queue timestamps must be timezone-aware UTC') |
| return value.astimezone(dt.timezone.utc) |
|
|
| def timestamp(value): |
| return utc(value).isoformat(timespec='seconds').replace('+00:00','Z') |
|
|
| def atomic(path,text): |
| path=Path(path);path.parent.mkdir(parents=True,exist_ok=True) |
| fd,tmp=tempfile.mkstemp(prefix='.'+path.name+'.',dir=path.parent) |
| try: |
| with os.fdopen(fd,'w',encoding='utf-8',newline='') as f: |
| f.write(text);f.flush();os.fsync(f.fileno()) |
| os.replace(tmp,path) |
| finally: |
| if os.path.exists(tmp):os.unlink(tmp) |
|
|
| def load_jobs(root): |
| rows=read_jsonl(root/'planning/subfield_jobs.jsonl') |
| ids=[str(r['subfield_id']) for r in rows] |
| if len(ids)!=len(set(ids)):raise ValueError('Duplicate prepared subfield job') |
| with (root/'taxonomy/openalex_subfields.csv').open(newline='',encoding='utf-8') as f: |
| taxonomy=list(csv.DictReader(f)) |
| taxids=[str(r['subfield_id']) for r in taxonomy] |
| if len(taxids)!=len(set(taxids)) or set(taxids)!=set(ids): |
| raise ValueError('Prepared job IDs differ from the saved official subfield taxonomy') |
| return rows |
|
|
| def collection_mapping(root,defs,known): |
| p=root/'planning/collection_subfield_map.json' |
| config=json.loads(p.read_text()) if p.exists() else {'schema_version':1,'collections':{}} |
| if config.get('schema_version')!=1 or not isinstance(config.get('collections'),dict): |
| raise ValueError('Invalid explicit collection mapping') |
| registered={d['collection'] for d in defs} |
| if set(config['collections'])-registered:raise ValueError('Mapping names an unknown collection') |
| result={} |
| for d in defs: |
| key=d['collection'];entry=config['collections'].get(key) |
| if entry is None: |
| sid=d.get('openalex_subfield_id') |
| entry={'subfield_ids':[str(sid)] if sid else [],'basis':'explicit_collection_definition' if sid else 'unassigned','rationale':'Explicit subfield association in the collection definition.' if sid else 'No explicit subfield mapping.'} |
| ids=entry.get('subfield_ids') |
| if not isinstance(ids,list) or any(not isinstance(s,str) or s not in known for s in ids) or len(set(ids))!=len(ids): |
| raise ValueError('Invalid mapped subfield IDs for '+key) |
| result[key]=entry |
| return result |
|
|
| def historical_finishes(root): |
| result={} |
| for p in sorted((root/'planning').glob('*search_progress.jsonl')): |
| for row in read_jsonl(p): |
| sid=str(row.get('subfield_id',''));finished=row.get('finished_at_utc','') |
| if sid and finished and (sid not in result or utc(finished)>utc(result[sid])):result[sid]=timestamp(finished) |
| return result |
|
|
| def build(root,now=None): |
| root=Path(root);now=utc(now);jobs=load_jobs(root);known={str(j['subfield_id']) for j in jobs} |
| defs=json.loads((root/'collections.json').read_text()) |
| if not isinstance(defs,list) or len({d['collection'] for d in defs})!=len(defs):raise ValueError('Invalid collection definitions') |
| mapping=collection_mapping(root,defs,known) |
| records=read_jsonl(root/'data/verified_links.jsonl') |
| grouped=collections.defaultdict(list) |
| for r in records: |
| if r.get('status')!='downloaded_and_screened' or not re.fullmatch('[0-9a-f]{64}',r.get('sha256','')): |
| raise ValueError('Queue counts require verified complete-file SHA256 records') |
| if r['collection'] not in mapping:raise ValueError('Verified row has an unknown collection') |
| grouped[r['collection']].append(r) |
| state_path=root/STATE_PATH |
| state=json.loads(state_path.read_text()) if state_path.exists() else {'schema_version':1,'tasks':{}} |
| if state.get('schema_version')!=1 or not isinstance(state.get('tasks'),dict) or set(state['tasks'])-known: |
| raise ValueError('Invalid authoritative queue state') |
| per=collections.defaultdict(list);cols=collections.defaultdict(list);unassigned=[] |
| for d in defs: |
| c=d['collection'];ids=mapping[c]['subfield_ids'] |
| if not ids: |
| unassigned.append({'collection':c,'verified_entries':len(grouped[c]),'valid_pdf_count':len({r['sha256'] for r in grouped[c]}),'reason':mapping[c].get('rationale','')}) |
| for sid in ids: |
| per[sid].extend(grouped[c]);cols[sid].append(c) |
| finishes=historical_finishes(root);rows=[] |
| for j in jobs: |
| sid=str(j['subfield_id']);t=state['tasks'].get(sid,{}) |
| if not isinstance(t,dict):raise ValueError('Invalid state task '+sid) |
| for name in ['generation','completed_rounds','last_new_entries','last_new_pdfs']: |
| if type(t.get(name,0)) is not int or t.get(name,0)<0:raise ValueError('Invalid queue counter '+name) |
| for name in ['lease_expires_at','cooldown_until','last_search_at']: |
| if t.get(name):utc(t[name]) |
| leased=bool(t.get('lease_expires_at')) and utc(t['lease_expires_at'])>now |
| cooling=bool(t.get('cooldown_until')) and utc(t['cooldown_until'])>now |
| if leased and (not t.get('owner') or not t.get('lease_id') or t.get('generation',0)<1):raise ValueError('Active lease lacks owner or fencing identity') |
| picked=per[sid];hashes={r['sha256'] for r in picked} |
| row={k:j.get(k,'') for k in ['domain_id','domain_name','field_id','field_name','subfield_name','topic_count','prompt_file']} |
| row.update(subfield_id=sid,valid_pdf_count=len(hashes),book_scope_pdf_count=len({r['sha256'] for r in picked if r['work_type'] in BOOK_TYPES}),verified_entry_count=len(picked),distinct_pdf_url_count=len({r['pdf_url'] for r in picked}),collection_count=len(cols[sid]),collection_ids=';'.join(sorted(cols[sid])),count_basis='explicit_editorial_collection_assignments',availability='claimed' if leased else 'cooldown' if cooling else 'available',historical_round_status=j.get('status','planned'),completed_rounds=t.get('completed_rounds',0),last_search_at=t.get('last_search_at','') or finishes.get(sid,''),last_new_entries=t.get('last_new_entries',0),last_new_pdfs=t.get('last_new_pdfs',0),owner=t.get('owner','') if leased else '',lease_id=t.get('lease_id','') if leased else '',generation=t.get('generation',0),lease_expires_at=t.get('lease_expires_at','') if leased else '',cooldown_until=t.get('cooldown_until','')) |
| rows.append(row) |
| rows.sort(key=lambda r:(r['valid_pdf_count'],r['last_search_at'],int(r['subfield_id']))) |
| for rank,row in enumerate(rows,1):row['priority']=rank |
| unmapped={c['collection'] for c in unassigned};unmapped_rows=[r for r in records if r['collection'] in unmapped] |
| mapped=[r for r in records if r['collection'] not in unmapped] |
| summary={'schema_version':1,'generated_at_utc':timestamp(now),'subfields':len(rows),'fields':len({str(j['field_id']) for j in jobs}),'domains':len({str(j['domain_id']) for j in jobs}),'global_verified_entries':len(records),'global_distinct_pdfs':len({r['sha256'] for r in records}),'global_distinct_pdf_urls':len({r['pdf_url'] for r in records}),'mapped_verified_entries':len(mapped),'mapped_distinct_pdfs':len({r['sha256'] for r in mapped}),'unassigned_verified_entries':len(unmapped_rows),'unassigned_distinct_pdfs':len({r['sha256'] for r in unmapped_rows}),'unassigned_collections':unassigned,'zero_pdf_subfields':sum(r['valid_pdf_count']==0 for r in rows),'nonzero_pdf_subfields':sum(r['valid_pdf_count']>0 for r in rows),'subfield_pdf_assignments':sum(r['valid_pdf_count'] for r in rows),'availability':dict(collections.Counter(r['availability'] for r in rows)),'mapping_basis':'Editorial collection-level assignments; not official per-work OpenAlex classification. Only primary IDs from the existing navigation crosswalk are counted. Unassigned works remain in the catalogue but are excluded from subfield counts.','coverage_note':'A zero means no explicitly mapped screened PDF in this catalogue, not that no public work exists. Subfield rounds do not establish exhaustive topic coverage. completed_rounds counts completions through this queue since initialization; historical rounds retain their separate status.','canonical_catalogue_sha256':hashlib.sha256((root/'data/verified_links.jsonl').read_bytes()).hexdigest()} |
| return rows,summary |
|
|
| def render(root,now=None): |
| root=Path(root);rows,summary=build(root,now) |
| out=io.StringIO(newline='');writer=csv.DictWriter(out,fieldnames=QUEUE_FIELDS);writer.writeheader();writer.writerows(rows) |
| atomic(root/CSV_PATH,out.getvalue());atomic(root/SUMMARY_PATH,json.dumps(summary,ensure_ascii=False,indent=2)+'\n') |
| return summary |
|
|
| def validate(root): |
| root=Path(root);saved=json.loads((root/SUMMARY_PATH).read_text());rows,expected=build(root,now=saved['generated_at_utc']) |
| with (root/CSV_PATH).open(newline='',encoding='utf-8') as f: |
| reader=csv.DictReader(f) |
| if reader.fieldnames!=QUEUE_FIELDS:raise ValueError('Workqueue CSV header differs') |
| actual=list(reader) |
| normalized=[{k:str(r[k]) for k in QUEUE_FIELDS} for r in rows] |
| if actual!=normalized or saved!=expected:raise ValueError('Workqueue counts or states are stale') |
| return expected |
|
|
| if __name__=='__main__': |
| p=argparse.ArgumentParser();p.add_argument('action',choices=['render','validate']);p.add_argument('root',type=Path,nargs='?',default=ROOT);a=p.parse_args() |
| print(json.dumps(render(a.root) if a.action=='render' else validate(a.root),ensure_ascii=False)) |
|
|
