| |
| """AhaSignals company PIT release selection, verification and offline replay.""" |
| import argparse,datetime as dt,hashlib,json,re,time,urllib.request |
| from pathlib import Path |
| import sys |
| sys.dont_write_bytecode=True |
| import packet |
|
|
| PAGE='https://ahasignals.com/research/company-pit-observations/' |
| ROOT='https://ahasignals.com/data/company-pit/v1/' |
| FILES={'snapshot.json','screen.json','study.json','coverage.json','review-candidates.jsonl','replay.py','packet.py','README.md','citation.bib'} |
| def encode(v):return (json.dumps(v,ensure_ascii=False,sort_keys=True,separators=(',',':'))+'\n').encode() |
| def digest(b):return hashlib.sha256(b).hexdigest() |
| def check(ok,why): |
| if not ok:raise ValueError(why) |
| def select(index,as_of): |
| cutoff=packet.instant(as_of) |
| rows=index['releases'];seen=set();previous=None |
| for r in rows: |
| check(packet.sha(r['sha256']) and r['sha256'] not in seen,'Invalid or duplicate release hash');seen.add(r['sha256']) |
| clock=packet.instant(r['frozenAt']);check(previous is None or clock>previous,'Unordered release catalog');previous=clock |
| check(r['releaseUrl']==ROOT+'releases/'+r['sha256']+'/release.json','Unexpected release URL') |
| eligible=[r for r in rows if packet.instant(r['frozenAt'])<=cutoff] |
| return eligible[-1] if eligible else None |
|
|
| def verify(folder,expected): |
| folder=Path(folder);raw=(folder/'release.json').read_bytes() |
| check(packet.sha(expected) and digest(raw)==expected,'Release SHA-256 mismatch') |
| r=json.loads(raw) |
| check(set(r)=={'version','publisher','frozenAt','sourceAsOf','sourceIndexSha256','previousReleaseSha256','builderSha256','files','boundary'},'Unknown release fields') |
| check(r['version']=='1.0.0' and r['publisher']=='AhaSignals','Unknown release contract') |
| clock=packet.instant(r['frozenAt']);check(packet.instant(r['sourceAsOf'])<=clock,'Future source snapshot') |
| check(set(r['files'])==FILES and packet.sha(r['builderSha256']),'Unexpected release files') |
| check(r['previousReleaseSha256'] is None or packet.sha(r['previousReleaseSha256']),'Invalid release parent') |
| for name,sha in r['files'].items():check(packet.sha(sha) and digest((folder/name).read_bytes())==sha,'File hash mismatch: '+name) |
| i=json.loads((folder/'snapshot.json').read_bytes());c=json.loads((folder/'coverage.json').read_bytes()) |
| check(digest(encode(i))==r['sourceIndexSha256'] and i['asOf']==r['sourceAsOf'],'Source index mismatch') |
| check(i['screenSha256']==digest((folder/'screen.json').read_bytes()) and i['studySha256']==digest((folder/'study.json').read_bytes()),'Source report mismatch') |
| check(len(i['companies'])==c['companyCount'] and len(c['companies'])==c['companyCount'],'Coverage count mismatch') |
| check(len({x['cik'] for x in i['companies']})==len(i['companies']),'Duplicate issuer') |
| for e in i['companies']: |
| check(re.fullmatch(r'\d{10}',e['cik']) and packet.sha(e['sha256']),'Invalid company identity') |
| check(e['packetUrl']=='/data/company-evidence/v1/packets/'+e['sha256']+'.json','Unexpected packet URL') |
| check(packet.instant(e['updatedAt'])<=clock and packet.instant(e['lastCheckedAt'])<=clock,'Company clock after release') |
| check(c['frozenAt']==r['frozenAt'],'Coverage clock mismatch') |
| return r,i,c |
|
|
| def replay(folder,expected,as_of,cik,cache): |
| r,i,c=verify(folder,expected);cutoff=packet.instant(as_of) |
| check(packet.instant(r['frozenAt'])<=cutoff,'Release unavailable at cutoff; select an older retained release. No backdating.') |
| entry=next((e for e in i['companies'] if e['cik']==cik),None) |
| check(entry is not None,'Issuer absent from this frozen universe; do not use current membership') |
| p=packet.verify((Path(cache)/(entry['sha256']+'.json')).read_bytes(),entry['sha256']) |
| check(p['cik']==cik and p['recordedAt']==entry['updatedAt'],'Wrong issuer or packet clock') |
| check(packet.instant(p['recordedAt'])<=packet.instant(r['frozenAt']),'Packet created after release') |
| result=packet.replay(p,as_of) |
| result.update(releaseSha256=expected,releaseFrozenAt=r['frozenAt'],sourceIndexSha256=r['sourceIndexSha256'],packetSha256=entry['sha256'],screenStatus=entry['status'],collectionError=entry['collectionError'],boundary='Facts and membership of this pinned release, not a live query. Select the latest retained release no later than the requested cutoff. A later cutoff does not refresh these observations; no proof of first public web availability.') |
| return result |
|
|
| def fetch(folder,expected,cache,cik=None,all_companies=False): |
| _,i,_=verify(folder,expected) |
| check(bool(cik)!=bool(all_companies),'Choose exactly one CIK or --all') |
| entries=i['companies'] if all_companies else [e for e in i['companies'] if e['cik']==cik] |
| check(bool(entries),'Issuer absent from frozen universe') |
| cache=Path(cache);cache.mkdir(parents=True,exist_ok=True) |
| class NoRedirect(urllib.request.HTTPRedirectHandler): |
| def redirect_request(self,*args,**kwargs):return None |
| opener=urllib.request.build_opener(NoRedirect) |
| for e in entries: |
| dest=cache/(e['sha256']+'.json') |
| if dest.exists(): |
| p=packet.verify(dest.read_bytes(),e['sha256']);check(p['cik']==e['cik'],'Cached issuer mismatch');continue |
| |
| req=urllib.request.Request('https://ahasignals.com'+e['packetUrl'],headers={'User-Agent':'AhaSignals-PIT-replay/1.0'}) |
| with opener.open(req,timeout=30) as response:raw=response.read(10_000_001) |
| check(len(raw)<=10_000_000,'Packet exceeds size limit');p=packet.verify(raw,e['sha256']);check(p['cik']==e['cik'],'Issuer mismatch') |
| dest.write_bytes(raw);time.sleep(.5) |
| return {'verifiedPackets':len(entries),'boundary':'Previously cached valid packets are reused. No credentials or SEC requests.'} |
|
|
| def main(): |
| a=argparse.ArgumentParser(description=__doc__);a.add_argument('command',choices=['select','verify','fetch','replay']);a.add_argument('--catalog',type=Path);a.add_argument('--release',type=Path);a.add_argument('--sha256');a.add_argument('--as-of');a.add_argument('--cik');a.add_argument('--all',action='store_true');a.add_argument('--cache',type=Path,default=Path('packets'));v=a.parse_args() |
| try: |
| if v.command=='select': |
| check(v.catalog is not None and v.as_of is not None,'--catalog and --as-of required');result=select(json.loads(v.catalog.read_bytes()),v.as_of);check(result is not None,'No retained release at or before cutoff') |
| else: |
| check(v.release is not None and v.sha256 is not None,'--release and externally pinned --sha256 required') |
| if v.command=='verify':r,i,c=verify(v.release,v.sha256);result={'verified':True,'frozenAt':r['frozenAt'],'companyCount':len(i['companies']),'coverageStatus':c['status']} |
| elif v.command=='fetch':result=fetch(v.release,v.sha256,v.cache,v.cik,v.all) |
| else: |
| check(v.as_of is not None and v.cik is not None,'--as-of and --cik required');result=replay(v.release,v.sha256,v.as_of,v.cik,v.cache) |
| print(json.dumps(result,ensure_ascii=False,indent=2)) |
| except (ValueError,KeyError,FileNotFoundError,TypeError) as e:a.exit(2,'Unavailable: '+str(e)+'\n') |
| if __name__=='__main__':main() |
|
|
