akg-factor-bridge/test_rating_priority.py

129 lines
9.0 KiB
Python
Raw Normal View History

"""离线:30日边界、证据与同档排序,真实刷新路径及固定版本重放。"""
import copy
import datetime as dt
from contextlib import ExitStack
import tempfile
import unittest
from unittest.mock import patch
import pandas as pd
import test_plan_versions as fixture
import sources, config, plan, plan_inputs as pi, plan_versions as pv, plan_refresh
import rating_priority as rating
import card
AT='2026-10-06T01:00:00+00:00'
EDGE='2026-11-05T09:00:00+08:00'
def review(grade='中'):
return {'overall':grade,'qual':'ok','brain_status':'ok','review_ref':'b'*64,'age_days':1}
def history():
return {'ts_code':'600001.SH','review_ref':'b'*64,'grade':'中','event_id':'b'*64,
'report_ran_at':AT,'recorded_at':AT,'last_change_json':{'event_id':'b'*64,
'direction':'down','before':'好','after':'中','before_ref':'a'*64,'after_ref':'b'*64,'at':AT}}
class PriorityTest(unittest.TestCase):
def test_boundary_timezone_same_grade_and_latest(self):
before=dt.datetime.fromisoformat(EDGE)-dt.timedelta(microseconds=1)
a=rating.evaluate(review(),history(),before.isoformat())
self.assertEqual(a['priority'],-1)
self.assertEqual(rating.evaluate(review(),history(),EDGE)['priority'],0)
same=history();same.update(review_ref='c'*64,report_ran_at='2026-11-04T01:00:00+00:00')
r={**review(),'review_ref':'c'*64}
self.assertEqual(rating.evaluate(r,same,EDGE)['status'],'expired')
self.assertEqual(a,rating.evaluate(review(),history(),before.astimezone(dt.timezone.utc).isoformat()))
up=history();up['grade']='好';up['last_change_json'].update(direction='up',before='中',after='好',at='2026-11-04T01:00:00+00:00')
up['report_ran_at']='2026-11-04T01:00:00+00:00'
self.assertEqual(rating.evaluate(review('好'),up,EDGE)['priority'],1)
def test_baseline_missing_invalid_and_future(self):
self.assertEqual(rating.evaluate(review(),None,EDGE)['status'],'missing_history')
h=history();h['last_change_json']=None
self.assertEqual(rating.evaluate(review(),h,EDGE)['status'],'baseline')
for modified in ({'qual':'error'},{'brain_status':'timeout'},{'review_ref':'c'*64},{'overall':'证据不足'}):
self.assertEqual(rating.evaluate({**review(),**modified},history(),EDGE)['priority'],0)
for field in ('recorded_at','report_ran_at'):
self.assertEqual(rating.evaluate(review(),{**history(),field:'2027-01-01T00:00:00Z'},EDGE)['status'],'future_history')
h=history();h['last_change_json']['before_ref']='invalid'
self.assertEqual(rating.evaluate(review(),h,EDGE)['status'],'invalid_history')
def test_quality_first_candidates_retained_scores_unchanged_and_flag_off(self):
ranked=pd.Series({'good':200.,'up':201.,'neutral':209.,'down':210.})
cards={k:{'verdict':'候选','quality_band':3 if k=='good' else 2,'gates':{'pointed':True},
'company_review':{'rating_priority':{'status':'active','priority':{'up':1,'down':-1}.get(k,0)}}} for k in ranked.index}
with patch.object(config,'PLAN_RATING_PRIORITY_ENABLED',True):
out=plan._rerank_by_axis(ranked,cards,'quality',120,True)
self.assertEqual(list(out.index),['good','up','neutral','down'])
self.assertEqual(out.to_dict(),ranked.to_dict())
self.assertTrue(all(c['verdict']=='候选' for c in cards.values()))
order=sorted(cards,key=lambda k:card.sort_key(cards[k],True,True))
self.assertEqual(order,['good','up','neutral','down'])
with patch.object(config,'PLAN_RATING_PRIORITY_ENABLED',False):
self.assertEqual(list(plan._rerank_by_axis(ranked,cards,'quality',120,True).index),['good','neutral','up','down'])
def test_source_separate_tables_scope_failure_and_match(self):
calls=[]
def read(sql,args):
calls.append((sql,args));self.assertNotIn('JOIN',sql)
self.assertEqual(args[0],['600001.SH'])
if 'company_review_runs' in sql:
return pd.DataFrame([{'ts_code':'600001.SH','summary':review(),'brain_status':'ok','ran_at':AT}])
return pd.DataFrame([history()])
rows=sources.company_reviews(['SH600001','920001.BJ'],'2026-11-04',read_pg=read,cutoff_at=EDGE,include_rating=True)
self.assertEqual(len(calls),2)
self.assertEqual(rows['SH600001']['rating_priority']['status'],'expired')
with self.assertRaises(OSError):
sources.company_reviews(['SH600001'],'2026-11-04',read_pg=lambda sql,args: read(sql,args) if 'company_review_runs' in sql else (_ for _ in ()).throw(OSError('history unavailable')),cutoff_at=EDGE,include_rating=True)
def test_old_frozen_params_do_not_inherit_current_enabled_switch(self):
with patch.object(config, 'PLAN_RATING_PRIORITY_ENABLED', True):
with pi.Bundle(records={}, params={}).use():
self.assertFalse(plan.config.PLAN_RATING_PRIORITY_ENABLED)
with pi.Bundle(params={}).use():
self.assertTrue(plan.config.PLAN_RATING_PRIORITY_ENABLED)
def test_frozen_replay_does_not_read_or_expire(self):
source=lambda *a,**kw: {'SH600001':{**review(),'rating_priority':rating.evaluate(review(),history(),kw['cutoff_at'])}}
bundle=pi.Bundle(params={'PLAN_RATING_PRIORITY_ENABLED':True},cutoff_at='2026-11-05T08:59:00+08:00')
value=bundle.call('sources.company_reviews',source,(['SH600001'],'2026-11-04'),{})
replay=pi.Bundle(records=bundle.records,params=bundle.params,cutoff_at='2030-01-01T00:00:00Z')
again=replay.call('sources.company_reviews',lambda *a,**kw:self.fail('回源'),(['SH600001'],'2026-11-04'),{})
self.assertEqual(value,again)
self.assertEqual(again['SH600001']['rating_priority']['priority'],-1)
class RefreshTest(unittest.TestCase):
def test_expiration_publishes_once_and_keeps_morning(self):
import factors, judgement, logic_state_daily
codes=['SH600001','SH600002'];day='2026-11-04';cut='2026-11-05T08:59:00+08:00'
with tempfile.TemporaryDirectory() as root, ExitStack() as stack:
def stub(obj,name,**kw):return stack.enter_context(patch.object(obj,name,**kw))
stub(config,'PLAN_SNAPSHOT_DIR',new=root)
stub(config,'PLAN_RATING_PRIORITY_ENABLED',new=True)
stub(config,'PLAN_RANK_AXIS',new='quality')
stub(plan,'_factor',side_effect=lambda table,day:pd.Series([240.,230.] if 'score' in table else [.3,.2] if 'upside' in table else [2.,2.],index=codes))
stub(plan,'_latest_date',return_value=day);stub(plan,'_prev_date',return_value=None)
stub(plan,'_names',return_value=dict(zip(codes,['甲','乙'])))
stub(plan,'_evidence',return_value=({c:('材料',3,.1,10,1) for c in codes},{day}))
stub(plan,'_segments_of',return_value={});stub(factors,'_risk_set',return_value=set())
stub(judgement,'load_previous',return_value=[]);stub(judgement,'recent_rows',return_value={})
stub(logic_state_daily,'history',return_value={})
for name in ('moved_members','broker_reports','logic_claims','broker_actions','close_prices','valuation_scenarios','analyst_events','event_day_fields','news_flashes','segment_catalysts','catalysts_for_codes'):
stub(sources,name,return_value={})
stub(sources,'stock_daily',return_value={c:{'pct0':3} for c in codes})
stub(sources,'night_conclusions',return_value={c:{'accum_state':'明确吸筹','accum_age':0} for c in codes})
def read(*a,**kw):
return {c:{**review(),'rating_priority':rating.evaluate(review(),history() if i==0 else None,kw['cutoff_at'])} for i,c in enumerate(codes)}
stub(sources,'company_reviews',side_effect=read)
b=pi.Bundle(params=pi.effective_config(config),cutoff_at=cut)
with b.use(): data=plan.collect(day)
data.update(data.pop('_full'))
with pv.writer(root):morning=pv.publish(root,data,{'records':b.records,'market':{},'regime':None},b.params,cutoff_at=cut,reason='晨版')
self.assertEqual(morning['main'][0]['code'],codes[1])
stub(plan_refresh,'in_window',return_value=True)
self.assertEqual(plan_refresh.refresh(now=dt.datetime.fromisoformat(EDGE))['status'],'published')
latest=pv.load(root,day)
self.assertEqual(latest['main'][0]['code'],codes[0])
self.assertEqual(latest['main'][0]['rating_priority']['status'],'expired')
self.assertNotIn('rating_priority',latest['main'][0]['company_review'])
self.assertEqual(pv.load(root,day,morning=True),morning)
self.assertEqual(plan_refresh.refresh(now=dt.datetime.fromisoformat(EDGE)+dt.timedelta(minutes=5))['status'],'unchanged')
stub(config,'PLAN_RATING_PRIORITY_ENABLED',new=False)
self.assertEqual(plan_refresh.refresh(now=dt.datetime.fromisoformat(EDGE)+dt.timedelta(minutes=10))['status'],'published')
self.assertFalse(pv.load(root,day)['rating_priority_policy']['enabled'])
if __name__=='__main__':unittest.main()