| import csv |
| import datetime as dt |
| import hashlib |
| import json |
| import shutil |
| import tempfile |
| import threading |
| import unittest |
| from concurrent.futures import ThreadPoolExecutor |
| from pathlib import Path |
| import sys |
| from unittest.mock import patch |
| from pypdf import PdfWriter |
| sys.path.insert(0, str(Path(__file__).resolve().parent)) |
| import workqueue as w |
|
|
| class FakeCounts: |
| @staticmethod |
| def build(root, now=None): |
| root=Path(root); jobs=w.jobs(root); defs=json.loads((root/'collections.json').read_text()); mapping=json.loads((root/'planning/collection_subfield_map.json').read_text()).get('collections',{}) |
| verified=[json.loads(x) for x in (root/'data/verified_links.jsonl').read_text().splitlines() if x.strip()] |
| hashes={sid:set() for sid in jobs} |
| for definition in defs: |
| entry=mapping.get(definition['collection'],{}) |
| sids=entry.get('subfield_ids',[]) or ([str(definition['openalex_subfield_id'])] if definition.get('openalex_subfield_id') else []) |
| for sid in sids: |
| hashes.setdefault(str(sid),set()).update(r['sha256'] for r in verified if r['collection']==definition['collection']) |
| rows=[{'subfield_id':sid,'valid_pdf_count':len(hashes.get(sid,set()))} for sid in jobs] |
| return rows,{} |
| @staticmethod |
| def render(root, now=None): |
| root=Path(root); (root/'planning').mkdir(exist_ok=True) |
| counts,_=FakeCounts.build(root,now); rows=[] |
| for j in w.jobs(root).values(): |
| s=w.load_state(root)['tasks'].get(str(j['subfield_id']),{}) |
| count=next(r['valid_pdf_count'] for r in counts if str(r['subfield_id'])==str(j['subfield_id'])) |
| rows.append({'subfield_id':j['subfield_id'],'valid_pdf_count':count,'last_search_at':s.get('last_search_at',''),'availability':'available','owner':s.get('owner',''),'lease_id':s.get('lease_id',''),'generation':s.get('generation',0),'lease_expires_at':s.get('lease_expires_at',''),'cooldown_until':s.get('cooldown_until','')}) |
| with (root/w.CSV).open('w',newline='') as f: |
| cols=list(rows[0]) if rows else ['subfield_id']; wr=csv.DictWriter(f,fieldnames=cols); wr.writeheader(); wr.writerows(rows) |
| (root/w.SUMMARY).write_text(json.dumps({'jobs':len(rows)})) |
|
|
| class FakeCAS(RuntimeError): |
| status_code=409 |
|
|
| class FakeCatalog: |
| @staticmethod |
| def read_rows(path): return [json.loads(s) for s in Path(path).read_text().splitlines() if s.strip()] |
| @staticmethod |
| def render(root): |
| root=Path(root); defs=json.loads((root/'collections.json').read_text()); rows=FakeCatalog.read_rows(root/'data/verified_links.jsonl') |
| for c in defs: c['verified_entries']=sum(r['collection']==c['collection'] for r in rows); c['legacy_candidates']=0 |
| (root/'collections.json').write_text(json.dumps(defs)) |
| return None |
| @staticmethod |
| def validate(root): return True |
|
|
| class FakeBackend: |
| def __init__(self,repo,now): self.repo=Path(repo); self.now=now; self.head_id=1; self.conflict=False; self.commits=0; self.lock=threading.Lock(); self.barrier=None; self.snapshot_count=0 |
| def head(self): return str(self.head_id) |
| def server_now(self): return self.now |
| def snapshot(self,revision,dest): |
| barrier=None |
| with self.lock: |
| self.snapshot_count+=1 |
| if self.barrier is not None and self.snapshot_count<=2: barrier=self.barrier |
| shutil.copytree(self.repo,dest) |
| if barrier: barrier.wait(timeout=5) |
| def commit(self,base,files,message): |
| with self.lock: |
| if str(self.head_id)!=str(base): raise FakeCAS('CAS conflict') |
| if self.conflict: |
| self.conflict=False |
| data=self.repo/'data/verified_links.jsonl' |
| rows=[json.loads(x) for x in data.read_text().splitlines() if x.strip()] |
| rows.append(self.competitor) |
| data.write_text(''.join(json.dumps(x)+'\n' for x in rows)); self.head_id+=1 |
| raise FakeCAS('CAS conflict') |
| for rel,path in files.items(): |
| out=self.repo/rel; out.parent.mkdir(parents=True,exist_ok=True); shutil.copy2(path,out) |
| self.head_id+=1; self.commits+=1 |
|
|
| class WorkqueueTests(unittest.TestCase): |
| def fixture(self): |
| td=tempfile.TemporaryDirectory(); root=Path(td.name)/'checkout'; root.mkdir(); (root/'planning').mkdir(); (root/'data').mkdir() |
| jobs=[] |
| for sid in (3200,3201): jobs.append({'subfield_id':str(sid),'field_id':'32','subfield_name':f'Subfield {sid}','suggested_collection':f'{sid}_subfield','suggested_group':'psychology','suggested_public_path':f'psychology/{sid}_subfield','valid_pdf_count':0}) |
| (root/'planning/subfield_jobs.jsonl').write_text(''.join(json.dumps(j)+'\n' for j in jobs)) |
| (root/'planning/collection_subfield_map.json').write_text(json.dumps({'schema_version':1,'collections':{'prior_3200':{'subfield_ids':['3200']},'prior_3201':{'subfield_ids':['3201']}}})) |
| defs=[{'collection':name,'group':'psychology','path':f'psychology/{name}','display_name':name,'verified_entries':1,'legacy_candidates':0} for name in ('prior_3200','prior_3201')] |
| (root/'collections.json').write_text(json.dumps(defs)); (root/'data/legacy_candidates.jsonl').write_text(''); (root/'data/release_summary.json').write_text('{}') |
| now=dt.datetime(2026,1,1,tzinfo=dt.timezone.utc); backend=FakeBackend(root,now) |
| scratch_tmp=tempfile.TemporaryDirectory(prefix='workqueue-test-') |
| self.addCleanup(scratch_tmp.cleanup); scratch=Path(scratch_tmp.name) |
| writer=PdfWriter(); [writer.add_blank_page(width=72,height=72) for _ in range(4)] |
| pdf=scratch/'book.pdf' |
| with pdf.open('wb') as f: writer.write(f) |
| sha=hashlib.sha256(pdf.read_bytes()).hexdigest() |
| rec={k:'' for k in w.FIELDS}; rec.update(record_id='r1',work_id='sha256:'+sha,collection='3200_subfield',group='psychology',title='A textbook',authors='',year=None,work_type='textbook',pages=4,pdf_url='https://example.org/book.pdf',source_url='https://example.org/book',identifier='',status='downloaded_and_screened',checked_at='2026-01-01T00:00:00Z',sha256=sha,verification_note='Complete academic textbook screened.',source_notes='') |
| prior_rows=[] |
| for sid in ('3200','3201'): |
| old=dict(rec); old.update(record_id='prior-'+sid,collection='prior_'+sid,work_id='pdf:'+sha) |
| prior_rows.append(old) |
| (root/'data/verified_links.jsonl').write_text(''.join(json.dumps(r)+'\n' for r in prior_rows)) |
| proof={'local_pdf':str(pdf),'sha256':sha,'pages':4,'decision':'accept','complete':True,'academic_context':True,'public_access':True,'source_verified':True,'source_check_notes':'Institutional source page identifies the download.','pdf_url':rec['pdf_url'],'source_url':rec['source_url'],'reviewed_pages':[{'page':1,'notes':'Title and contents establish book scope.'},{'page':3,'notes':'Middle chapter confirms scope.'},{'page':4,'notes':'Final pages show complete work.'}]} |
| return td,root,scratch,backend,rec,proof,now |
|
|
| def test_false_like_completeness_flags_are_never_positive_evidence(self): |
| td,root,scratch,b,rec,proof,now=self.fixture(); self.addCleanup(td.cleanup) |
| for bad in (False,None,'false','true',1): |
| with self.subTest(complete=bad): |
| with self.assertRaises(ValueError): |
| w.verify_record(rec,dict(proof,complete=bad),scratch) |
| w.verify_record(rec,proof,scratch) |
|
|
| def test_two_claims_get_distinct_available_subfields(self): |
| td,root,scratch,b,rec,proof,now=self.fixture(); self.addCleanup(td.cleanup) |
| with patch.dict(sys.modules,{'workqueue_counts':FakeCounts}): |
| a=w.remote_lease('',root,'claim',{'owner':'00000000-0000-0000-0000-000000000001'},backend=b,scratch=scratch) |
| c=w.remote_lease('',root,'claim',{'owner':'00000000-0000-0000-0000-000000000002'},backend=b,scratch=scratch) |
| self.assertNotEqual(a['subfield_id'],c['subfield_id']) |
|
|
| def test_simultaneous_claims_retry_cas_and_get_distinct_subfields(self): |
| td,root,scratch,b,rec,proof,now=self.fixture(); self.addCleanup(td.cleanup); b.barrier=threading.Barrier(2) |
| with patch.dict(sys.modules,{'workqueue_counts':FakeCounts}): |
| with ThreadPoolExecutor(max_workers=2) as pool: |
| fs=[pool.submit(w.remote_lease,'',root,'claim',{'owner':f'00000000-0000-0000-0000-{i:012d}'},backend=b,scratch=scratch) for i in (1,2)] |
| claims=[f.result(timeout=10) for f in fs] |
| self.assertEqual(len({c['subfield_id'] for c in claims}),2) |
|
|
| def test_new_definition_and_retry_preserve_concurrent_row(self): |
| td,root,scratch,b,rec,proof,now=self.fixture(); self.addCleanup(td.cleanup) |
| with patch.dict(sys.modules,{'workqueue_counts':FakeCounts,'catalog':FakeCatalog}): |
| claim=w.remote_lease('',root,'claim',{'owner':'00000000-0000-0000-0000-000000000001'},backend=b,scratch=scratch) |
| rec2=dict(rec); rec2.update(record_id='competitor',sha256='a'*64,work_id='sha256:'+'a'*64,title='Concurrent accepted work') |
| b.competitor=rec2; b.conflict=True |
| result=w.publish(root,b,claim['subfield_id'],claim['owner'],claim['lease_id'],claim['generation'],[(rec,proof)],scratch) |
| self.assertTrue(result['published']) |
| rows=FakeCatalog.read_rows(root/'data/verified_links.jsonl') |
| self.assertEqual({r['record_id'] for r in rows},{'prior-3200','prior-3201','competitor','r1'}) |
| defs=json.loads((root/'collections.json').read_text()) |
| self.assertEqual(next(d for d in defs if d['collection']=='3200_subfield')['openalex_subfield_id'],'3200') |
|
|
| def test_old_expired_lease_cannot_publish_after_new_claim(self): |
| td,root,scratch,b,rec,proof,now=self.fixture(); self.addCleanup(td.cleanup) |
| with patch.dict(sys.modules,{'workqueue_counts':FakeCounts,'catalog':FakeCatalog}): |
| a=w.remote_lease('',root,'claim',{'owner':'00000000-0000-0000-0000-000000000001'},backend=b,scratch=scratch) |
| b.now+=dt.timedelta(minutes=31) |
| c=w.remote_lease('',root,'claim',{'owner':'00000000-0000-0000-0000-000000000002'},backend=b,scratch=scratch) |
| self.assertNotEqual(a['lease_id'],c['lease_id']) |
| with self.assertRaises(ValueError): w.publish(root,b,a['subfield_id'],a['owner'],a['lease_id'],a['generation'],[(rec,proof)],scratch) |
| self.assertEqual(w.load_state(root)['tasks'][a['subfield_id']]['completed_rounds'],0) |
|
|
| def test_duplicate_completion_does_not_increment_twice(self): |
| td,root,scratch,b,rec,proof,now=self.fixture(); self.addCleanup(td.cleanup) |
| with patch.dict(sys.modules,{'workqueue_counts':FakeCounts,'catalog':FakeCatalog}): |
| a=w.remote_lease('',root,'claim',{'owner':'00000000-0000-0000-0000-000000000001'},backend=b,scratch=scratch) |
| out=w.publish(root,b,a['subfield_id'],a['owner'],a['lease_id'],a['generation'],[(rec,proof),(rec,proof)],scratch) |
| self.assertEqual(out['new_entries'],1) |
| self.assertEqual(sum(r['record_id']=='r1' for r in FakeCatalog.read_rows(root/'data/verified_links.jsonl')),1) |
| self.assertEqual(w.load_state(root)['tasks'][a['subfield_id']]['last_new_pdfs'],0) |
| with self.assertRaises(ValueError): w.publish(root,b,a['subfield_id'],a['owner'],a['lease_id'],a['generation'],[(rec,proof)],scratch) |
| self.assertEqual(w.load_state(root)['tasks'][a['subfield_id']]['completed_rounds'],1) |
|
|
| if __name__=='__main__': unittest.main() |
|
|
