Datasets:
File size: 11,618 Bytes
239e8f8 de9b76d 239e8f8 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 | 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()
|