akg-factor-bridge/test_rating_priority.py

129 lines
9.0 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

"""离线: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()