563 lines
31 KiB
Python
563 lines
31 KiB
Python
from __future__ import annotations
|
|
|
|
import statistics
|
|
from collections import defaultdict
|
|
from datetime import datetime
|
|
from typing import Any
|
|
|
|
from backend.data.numbers import finite_number as _number
|
|
from backend.features.screener.indicators import (
|
|
_available_percentile_map,
|
|
_broken_reversal_metrics,
|
|
_ending_streak,
|
|
_is_limit_bar,
|
|
_limit_threshold,
|
|
_macd_last,
|
|
_macd_series,
|
|
_max_streak,
|
|
_optional_number,
|
|
_pearson,
|
|
_percentile_map,
|
|
_rounded_optional,
|
|
_rsi,
|
|
_touched_limit_bar,
|
|
_weekly_series,
|
|
)
|
|
from database import ReviewDatabase
|
|
|
|
|
|
class FactorBuilder:
|
|
def __init__(self, database: ReviewDatabase) -> None:
|
|
self.database = database
|
|
|
|
def build_factors(
|
|
self,
|
|
trade_date: str,
|
|
realtime_snapshot: dict[str, Any] | None = None,
|
|
history_days: int = 80,
|
|
) -> tuple[list[dict[str, Any]], str]:
|
|
history_days = max(21, min(260, int(history_days)))
|
|
data = self.database.load_factor_data(trade_date, history_days)
|
|
dates = [value for value in data["dates"] if value <= trade_date]
|
|
if len(dates) < 21:
|
|
raise ValueError("历史行情不足 21 个交易日，请先同步因子数据。")
|
|
history_date = dates[-1]
|
|
realtime_map = {
|
|
str(row.get("ts_code") or ""): row
|
|
for row in (realtime_snapshot or {}).get("rows") or []
|
|
}
|
|
realtime_date = str((realtime_snapshot or {}).get("trade_date") or "")
|
|
use_realtime = bool(realtime_map and realtime_date == trade_date and history_date < trade_date)
|
|
actual_date = trade_date if use_realtime else history_date
|
|
master = {row["ts_code"]: row for row in data["master"]}
|
|
indicators = {row["ts_code"]: row for row in data["indicators"]}
|
|
fundamentals = {row["ts_code"]: row for row in data.get("fundamentals", [])}
|
|
indicator_history: dict[str, list[dict[str, Any]]] = defaultdict(list)
|
|
for row in data.get("indicator_history", []):
|
|
indicator_history[str(row.get("ts_code") or "")].append(row)
|
|
indicator_series: dict[str, list[dict[str, Any]]] = defaultdict(list)
|
|
for row in data.get("indicator_series", []):
|
|
indicator_series[str(row.get("ts_code") or "")].append(row)
|
|
benchmark_by_date = {
|
|
str(row.get("trade_date") or ""): _number(row.get("close"))
|
|
for row in data.get("benchmarks", [])
|
|
if _number(row.get("close")) > 0
|
|
}
|
|
moneyflow = {row["ts_code"]: row for row in data["moneyflow"]}
|
|
moneyflow_history: dict[str, list[dict[str, Any]]] = defaultdict(list)
|
|
for row in data.get("moneyflow_history", []):
|
|
moneyflow_history[str(row.get("ts_code") or "")].append(row)
|
|
auction = {
|
|
row["ts_code"]: row
|
|
for row in data.get("auction", [])
|
|
if str(row.get("trade_date") or "") == actual_date
|
|
}
|
|
earnings_events: dict[str, dict[str, Any]] = {}
|
|
for row in data.get("earnings_events", []):
|
|
ts_code = str(row.get("ts_code") or "")
|
|
ann_date = str(row.get("ann_date") or "")
|
|
if ann_date <= actual_date and (
|
|
ts_code not in earnings_events
|
|
or ann_date > str(earnings_events[ts_code].get("ann_date") or "")
|
|
):
|
|
earnings_events[ts_code] = row
|
|
popularity = {
|
|
str(row.get("ts_code") or ""): row
|
|
for row in data.get("popularity", [])
|
|
}
|
|
institutions = {
|
|
str(row.get("ts_code") or ""): row
|
|
for row in data.get("institutions", [])
|
|
}
|
|
grouped: dict[str, list[dict[str, Any]]] = defaultdict(list)
|
|
for row in data["bars"]:
|
|
if row["trade_date"] <= history_date:
|
|
grouped[row["ts_code"]].append(row)
|
|
|
|
snapshot = self.database.get_snapshot(actual_date) or {}
|
|
limit_map: dict[str, tuple[str, int]] = {}
|
|
for key, status in (("limits", "涨停"), ("broken", "炸板"), ("down_limits", "跌停")):
|
|
for row in snapshot.get(key) or []:
|
|
limit_map[str(row.get("code"))] = (status, int(row.get("streak") or 0))
|
|
|
|
factors = []
|
|
current_day = datetime.strptime(actual_date, "%Y%m%d")
|
|
for ts_code, bars in grouped.items():
|
|
bars.sort(key=lambda item: item["trade_date"])
|
|
if len(bars) < 21 or bars[-1]["trade_date"] != history_date:
|
|
continue
|
|
info = master.get(ts_code)
|
|
if not info:
|
|
continue
|
|
historical_closes = [_number(item["close"]) for item in bars]
|
|
historical_volumes = [_number(item["vol"]) for item in bars]
|
|
realtime = realtime_map.get(ts_code) if use_realtime else None
|
|
current = realtime or bars[-1]
|
|
closes = historical_closes + ([_number(realtime["close"])] if realtime else [])
|
|
volumes = historical_volumes + ([_number(realtime["vol"])] if realtime else [])
|
|
if closes[-1] <= 0:
|
|
continue
|
|
returns_10 = [_number(item["pct_chg"]) for item in bars[-10:]]
|
|
if realtime:
|
|
returns_10 = returns_10[-9:] + [_number(realtime.get("pct_chg"))]
|
|
previous_volume = statistics.fmean(volumes[-6:-1]) if any(volumes[-6:-1]) else 0
|
|
indicator = indicators.get(ts_code, {})
|
|
fundamental = fundamentals.get(ts_code, {})
|
|
flow = moneyflow.get(ts_code, {})
|
|
flow_history = moneyflow_history.get(ts_code, [])
|
|
auction_row = auction.get(ts_code, {})
|
|
list_date = str(info.get("list_date") or "")
|
|
try:
|
|
listed_days = (current_day - datetime.strptime(list_date, "%Y%m%d")).days
|
|
except ValueError:
|
|
listed_days = 9999
|
|
code = str(info.get("code") or ts_code.split(".")[0])
|
|
status, streak = limit_map.get(code, ("", 0))
|
|
name = str(info.get("name") or "--")
|
|
shape_rows = bars + ([realtime] if realtime else [])
|
|
shape_close = [_number(item.get("close")) for item in shape_rows]
|
|
shape_high = [_number(item.get("high") or item.get("close")) for item in shape_rows]
|
|
shape_low = [_number(item.get("low") or item.get("close")) for item in shape_rows]
|
|
shape_changes = [_number(item.get("pct_chg")) for item in shape_rows]
|
|
position_rows = shape_rows[-60:]
|
|
position_high = max((_number(item.get("high") or item.get("close")) for item in position_rows), default=0)
|
|
position_low = min((_number(item.get("low") or item.get("close")) for item in position_rows), default=0)
|
|
relative_position = (
|
|
(closes[-1] - position_low) / (position_high - position_low)
|
|
if position_high > position_low else 0.5
|
|
)
|
|
previous_index = len(bars) - 1 if realtime else len(bars) - 2
|
|
previous_bar = bars[previous_index] if previous_index >= 0 else {}
|
|
previous_limit = _is_limit_bar(bars, previous_index, code, name)
|
|
previous_touched = _touched_limit_bar(bars, previous_index, code, name)
|
|
recent_prior_signal = any(
|
|
_is_limit_bar(bars, index, code, name)
|
|
or _touched_limit_bar(bars, index, code, name)
|
|
for index in range(max(0, previous_index - 2), previous_index)
|
|
)
|
|
previous_streak = 0
|
|
streak_index = previous_index
|
|
while streak_index >= 0 and _is_limit_bar(bars, streak_index, code, name):
|
|
previous_streak += 1
|
|
streak_index -= 1
|
|
limit_flags = [
|
|
_is_limit_bar(shape_rows, index, code, name)
|
|
for index in range(len(shape_rows))
|
|
]
|
|
annual_dividend_rows = indicator_history.get(ts_code, [])
|
|
dividend_years = sum(
|
|
1 for item in annual_dividend_rows if _optional_number(item.get("dv_ttm")) not in (None, 0)
|
|
)
|
|
current_streak = _ending_streak(limit_flags)
|
|
prior_streak = _ending_streak(limit_flags, len(limit_flags) - 2)
|
|
streak = max(streak, current_streak)
|
|
return_60d = (
|
|
(closes[-1] / closes[-61] - 1) * 100 if len(closes) >= 61 and closes[-61] else 0
|
|
)
|
|
momentum_60_5 = (
|
|
(closes[-6] / closes[-61] - 1) * 100 if len(closes) >= 61 and closes[-61] else 0
|
|
)
|
|
ma20 = statistics.fmean(closes[-20:])
|
|
ma60 = statistics.fmean(closes[-60:]) if len(closes) >= 60 else ma20
|
|
prior_ma20 = statistics.fmean(closes[-25:-5]) if len(closes) >= 25 else ma20
|
|
prior_ma60 = statistics.fmean(closes[-65:-5]) if len(closes) >= 65 else ma60
|
|
ma20_slope = (ma20 / prior_ma20 - 1) * 100 if prior_ma20 else 0
|
|
ma60_slope = (ma60 / prior_ma60 - 1) * 100 if prior_ma60 else 0
|
|
ma_values = [statistics.fmean(closes[-window:]) for window in (5, 10, 20, 60)]
|
|
high_250 = max(shape_high[-250:]) if len(shape_high) >= 250 else max(shape_high)
|
|
drawdown_250 = (1 - closes[-1] / high_250) * 100 if high_250 else 100
|
|
prior_high_20 = max(shape_high[-21:-1]) if len(shape_high) >= 21 else 0
|
|
breakout_pct = (closes[-1] / prior_high_20 - 1) * 100 if prior_high_20 else 0
|
|
prior_lows_20 = shape_low[-21:-1]
|
|
range_20d = (
|
|
(prior_high_20 / min(prior_lows_20) - 1) * 100
|
|
if prior_lows_20 and min(prior_lows_20) > 0 else 100
|
|
)
|
|
turnover_rows = sorted(
|
|
indicator_series.get(ts_code, []), key=lambda item: str(item.get("trade_date") or "")
|
|
)
|
|
turnover_values = [_number(item.get("turnover_rate")) for item in turnover_rows[-5:]]
|
|
if realtime and _number(realtime.get("turnover_rate")):
|
|
turnover_values = turnover_values[-4:] + [_number(realtime.get("turnover_rate"))]
|
|
turnover_5d = sum(turnover_values)
|
|
rs_values = [
|
|
_number(item.get("close")) / benchmark_by_date[str(item.get("trade_date"))]
|
|
for item in shape_rows[-120:]
|
|
if benchmark_by_date.get(str(item.get("trade_date"))) and _number(item.get("close")) > 0
|
|
]
|
|
benchmark_60 = [
|
|
benchmark_by_date.get(str(item.get("trade_date")))
|
|
for item in shape_rows[-61:]
|
|
if benchmark_by_date.get(str(item.get("trade_date")))
|
|
]
|
|
benchmark_return_60 = (
|
|
(benchmark_60[-1] / benchmark_60[0] - 1) * 100
|
|
if len(benchmark_60) >= 61 and benchmark_60[0] else 0
|
|
)
|
|
weekly_closes, weekly_amounts = _weekly_series(shape_rows)
|
|
weekly_dif, weekly_dea = _macd_last(weekly_closes)
|
|
daily_dif, daily_dea = _macd_series(closes)
|
|
daily_cross = (
|
|
len(daily_dif) >= 2 and daily_dif[-1] > daily_dea[-1]
|
|
and daily_dif[-2] <= daily_dea[-2]
|
|
)
|
|
current_open = _number(current.get("open"))
|
|
daily_pullback = closes[-1] >= ma20 and current_open <= ma20 * 1.02 and closes[-1] > current_open
|
|
previous_close = closes[-2] if len(closes) >= 2 else closes[-1]
|
|
intraday_min = (
|
|
(_number(current.get("low")) / previous_close - 1) * 100 if previous_close else 0
|
|
)
|
|
body = abs(closes[-1] - current_open)
|
|
lower_shadow = max(0.0, min(current_open, closes[-1]) - _number(current.get("low")))
|
|
lower_shadow_ratio = lower_shadow / body if body > 0 else (10.0 if lower_shadow > 0 else 0.0)
|
|
previous_volume_value = volumes[-2] if len(volumes) >= 2 else 0
|
|
vol_vs_previous = volumes[-1] / previous_volume_value if previous_volume_value else 0
|
|
broken = _broken_reversal_metrics(shape_rows, limit_flags, code, name)
|
|
netprofit_yoy = _optional_number(fundamental.get("netprofit_yoy"))
|
|
earnings_event = earnings_events.get(ts_code, {})
|
|
announcement_date = str(earnings_event.get("ann_date") or "")
|
|
earnings_days = (
|
|
sum(1 for value in dates if announcement_date < value <= actual_date)
|
|
if announcement_date and announcement_date <= actual_date
|
|
else None
|
|
)
|
|
announcement_bar = next(
|
|
(item for item in shape_rows if str(item.get("trade_date") or "") == announcement_date),
|
|
None,
|
|
)
|
|
announcement_bad = False
|
|
if announcement_bar is not None:
|
|
bar_index = shape_rows.index(announcement_bar)
|
|
prior_volumes = [
|
|
_number(item.get("vol")) for item in shape_rows[max(0, bar_index - 5):bar_index]
|
|
if _number(item.get("vol")) > 0
|
|
]
|
|
volume_baseline = statistics.fmean(prior_volumes) if prior_volumes else 0
|
|
announcement_bad = (
|
|
_number(announcement_bar.get("close")) < _number(announcement_bar.get("open"))
|
|
and _number(announcement_bar.get("pct_chg")) < 0
|
|
and volume_baseline > 0
|
|
and _number(announcement_bar.get("vol")) / volume_baseline >= 1.8
|
|
)
|
|
popularity_row = popularity.get(ts_code)
|
|
institution_row = institutions.get(ts_code)
|
|
factors.append(
|
|
{
|
|
"code": code,
|
|
"ts_code": ts_code,
|
|
"name": name,
|
|
"sector": info.get("industry") or "其他",
|
|
"market": info.get("market") or "--",
|
|
"listed_days": listed_days,
|
|
"close": round(closes[-1], 2),
|
|
"price": round(closes[-1], 2),
|
|
"pct_chg": round(_number(current["pct_chg"]), 2),
|
|
"return_5d": round((closes[-1] / closes[-6] - 1) * 100, 2),
|
|
"return_10d": round((closes[-1] / closes[-11] - 1) * 100, 2),
|
|
"return_20d": round((closes[-1] / closes[-21] - 1) * 100, 2),
|
|
"return_60d": round(return_60d, 2),
|
|
"momentum_60_5": round(momentum_60_5, 2),
|
|
"above_ma20": int(closes[-1] > ma20),
|
|
"rsi_6": round(_rsi(closes, 6), 2),
|
|
"ma60_slope": round(ma60_slope, 3),
|
|
"ma20_slope_5d": round(ma20_slope, 3),
|
|
"ma_bull_alignment": int(ma_values[0] > ma_values[1] > ma_values[2] > ma_values[3]),
|
|
"drawdown_from_high_250": round(drawdown_250, 2),
|
|
"donchian_breakout_pct": round(breakout_pct, 2),
|
|
"range_20d": round(range_20d, 2),
|
|
"rs_high_120": int(len(rs_values) >= 120 and rs_values[-1] >= max(rs_values)),
|
|
"excess_return_60d": round(return_60d - benchmark_return_60, 2),
|
|
"weekly_trend_signal": int(len(weekly_closes) >= 30 and weekly_dif > 0 and weekly_dea > 0),
|
|
"daily_buy_trigger": int(daily_cross or daily_pullback),
|
|
"weekly_amount_trend": int(
|
|
len(weekly_amounts) >= 5
|
|
and weekly_amounts[-1] >= statistics.fmean(weekly_amounts[-5:-1])
|
|
),
|
|
"volume_ratio_5d": round(volumes[-1] / previous_volume, 2) if previous_volume else 0,
|
|
"turnover_5d": round(turnover_5d, 2),
|
|
"volatility_10d": round(statistics.pstdev(returns_10), 2),
|
|
"amount_billion": round(
|
|
_number(current["amount"]) / (100000000 if realtime else 100000), 2
|
|
),
|
|
"turnover_rate": round(
|
|
_number(realtime.get("turnover_rate"))
|
|
if realtime else _number(indicator.get("turnover_rate")),
|
|
2,
|
|
),
|
|
"circ_mv_billion": round(_number(indicator.get("circ_mv")) / 10000, 2),
|
|
"total_mv_billion": round(_number(indicator.get("total_mv")) / 10000, 2),
|
|
"pe_ttm": _rounded_optional(indicator.get("pe_ttm"), 2),
|
|
"pb": _rounded_optional(indicator.get("pb"), 2),
|
|
"ps_ttm": _rounded_optional(indicator.get("ps_ttm"), 2),
|
|
"dividend_yield_ttm": _rounded_optional(indicator.get("dv_ttm"), 2),
|
|
"dividend_years": dividend_years,
|
|
"roe": _rounded_optional(fundamental.get("roe"), 2),
|
|
"roa": _rounded_optional(fundamental.get("roa"), 2),
|
|
"roic": _rounded_optional(fundamental.get("roic"), 2),
|
|
"gross_margin": _rounded_optional(fundamental.get("grossprofit_margin"), 2),
|
|
"netprofit_yoy": _rounded_optional(fundamental.get("netprofit_yoy"), 2),
|
|
"revenue_yoy": _rounded_optional(fundamental.get("or_yoy"), 2),
|
|
"ocf_to_opincome": _rounded_optional(fundamental.get("ocf_to_opincome"), 2),
|
|
"earnings_surprise_pct": _rounded_optional(earnings_event.get("surprise_pct"), 2),
|
|
"earnings_days_since_announce": earnings_days,
|
|
"earnings_event_quality": int(not announcement_bad) if earnings_days is not None else None,
|
|
"popularity_score": _rounded_optional(
|
|
popularity_row.get("combined_score") if popularity_row else None, 2
|
|
),
|
|
"popularity_rank_change": (
|
|
int(popularity_row["rank_change"])
|
|
if popularity_row and popularity_row.get("rank_change") is not None else None
|
|
),
|
|
"popularity_dual_source": (
|
|
int(bool(popularity_row.get("dual_source"))) if popularity_row else None
|
|
),
|
|
"institution_net_buy_million": (
|
|
round(_number(institution_row.get("net_buy_amount")) / 1_000_000, 2)
|
|
if institution_row else None
|
|
),
|
|
"institution_seat_count": (
|
|
int(institution_row.get("seat_count") or 0) if institution_row else None
|
|
),
|
|
"net_flow_million": round(_number(flow.get("net_mf_amount")) / 100, 2),
|
|
"large_flow_million": round(_number(flow.get("large_net_amount")) / 100, 2),
|
|
"net_flow_5d_million": round(
|
|
sum(_number(item.get("net_mf_amount")) for item in flow_history) / 100,
|
|
2,
|
|
),
|
|
"flow_to_circ_mv_5d": round(
|
|
sum(_number(item.get("net_mf_amount")) for item in flow_history)
|
|
/ _number(indicator.get("circ_mv")) * 100,
|
|
4,
|
|
) if _number(indicator.get("circ_mv")) else 0,
|
|
"limit_status": status,
|
|
"limit_streak": streak,
|
|
"is_limit_up_today": int(limit_flags[-1]),
|
|
"is_limit_down_today": int(_number(current.get("pct_chg")) <= -_limit_threshold(code, name)),
|
|
"auction_change": round(_number(auction_row.get("change")), 2),
|
|
"auction_amount_million": round(_number(auction_row.get("amount")) / 1_000_000, 2),
|
|
"auction_turnover_rate": round(_number(auction_row.get("turnover_rate")), 4),
|
|
"auction_volume_ratio": round(_number(auction_row.get("volume_ratio")), 2),
|
|
"relative_position_60": round(relative_position, 4),
|
|
"max_abs_change_15d": round(max((abs(value) for value in shape_changes[-15:]), default=0), 2),
|
|
"close_to_high_15d": round(closes[-1] / max(shape_high[-15:]), 4) if shape_high[-15:] and max(shape_high[-15:]) else 0,
|
|
"close_to_high_60d": round(closes[-1] / max(shape_high[-60:]), 4) if shape_high[-60:] and max(shape_high[-60:]) else 0,
|
|
"no_limit_30d": int(not any(limit_flags[-30:])),
|
|
"had_limit_80d": int(any(limit_flags[-80:-30] if len(limit_flags) > 30 else [])),
|
|
"no_limit_down_20d": int(not any(
|
|
_number(item.get("pct_chg")) <= -_limit_threshold(code, name)
|
|
for item in shape_rows[-20:]
|
|
)),
|
|
"financial_risk": int(
|
|
"ST" in name.upper() or "退" in name
|
|
or (netprofit_yoy is not None and netprofit_yoy <= -100)
|
|
),
|
|
"prior_limit_streak": prior_streak,
|
|
"max_continuous_board_10d": _max_streak(limit_flags[-10:]),
|
|
"dragon_first_yin": int(
|
|
prior_streak >= 3 and not limit_flags[-1] and closes[-1] < current_open
|
|
),
|
|
"yin_day_pct": round(_number(current.get("pct_chg")), 2),
|
|
"vol_vs_previous": round(vol_vs_previous, 3),
|
|
"broken_reversal": broken["signal"],
|
|
"days_since_broken": broken["days"],
|
|
"close_above_broken_high": broken["recovered"],
|
|
"vol_vs_broken_day": broken["volume_ratio"],
|
|
"recent_limit_up_5d": sum(limit_flags[-5:]),
|
|
"intraday_min_pct": round(intraday_min, 2),
|
|
"lower_shadow_ratio": round(lower_shadow_ratio, 2),
|
|
"previous_first_limit": int(previous_limit and not recent_prior_signal),
|
|
"previous_limit_signal": int((previous_limit or previous_touched) and not recent_prior_signal),
|
|
"previous_limit_streak": previous_streak,
|
|
"previous_amount_billion": round(_number(previous_bar.get("amount")) / 100000, 2),
|
|
}
|
|
)
|
|
|
|
market_return = statistics.fmean(row["return_5d"] for row in factors) if factors else 0
|
|
sectors: dict[str, list[dict[str, Any]]] = defaultdict(list)
|
|
for row in factors:
|
|
sectors[row["sector"]].append(row)
|
|
sector_metrics = []
|
|
market_amount = sum(max(0.0, row["amount_billion"]) for row in factors)
|
|
for sector_name, sector_rows in sectors.items():
|
|
average_return = statistics.fmean(row["return_5d"] for row in sector_rows)
|
|
average_return_20d = statistics.fmean(row["return_20d"] for row in sector_rows)
|
|
sector_net_flow = sum(row["net_flow_5d_million"] for row in sector_rows)
|
|
limit_count = sum(row["limit_status"] == "涨停" or row["pct_chg"] >= 9.5 for row in sector_rows)
|
|
up_count = sum(row["pct_chg"] >= 5 for row in sector_rows)
|
|
breadth_ma20 = sum(row["above_ma20"] for row in sector_rows) / max(len(sector_rows), 1) * 100
|
|
sector_growth = [
|
|
statistics.fmean(values)
|
|
for row in sector_rows
|
|
if (values := [
|
|
value for value in (row.get("revenue_yoy"), row.get("netprofit_yoy"))
|
|
if value is not None
|
|
])
|
|
]
|
|
prosperity_raw = statistics.median(sector_growth) if sector_growth else -100.0
|
|
average_turnover = statistics.fmean(row["turnover_rate"] for row in sector_rows)
|
|
amount_share = (
|
|
sum(max(0.0, row["amount_billion"]) for row in sector_rows) / market_amount * 100
|
|
if market_amount else 0.0
|
|
)
|
|
crowding_raw = average_turnover + amount_share
|
|
trend_raw = average_return_20d + breadth_ma20 / 10
|
|
strength = min(100, max(0, 50 + average_return * 4 + limit_count * 3 + up_count * 0.6))
|
|
sector_metrics.append(
|
|
{
|
|
"ts_code": sector_name,
|
|
"sector_return_20d": average_return_20d,
|
|
"sector_net_flow_5d_million": sector_net_flow,
|
|
"sector_prosperity_raw": prosperity_raw,
|
|
"sector_trend_raw": trend_raw,
|
|
"sector_crowding_raw": crowding_raw,
|
|
}
|
|
)
|
|
stock_momentum_ranks = _percentile_map(sector_rows, "return_20d", "desc")
|
|
for row in sector_rows:
|
|
row["sector_strength"] = round(strength, 1)
|
|
row["sector_return_5d"] = round(average_return, 2)
|
|
row["sector_return_20d"] = round(average_return_20d, 2)
|
|
row["sector_net_flow_5d_million"] = round(sector_net_flow, 2)
|
|
row["sector_stock_momentum_rank"] = round(
|
|
stock_momentum_ranks.get(row["ts_code"], 0.0), 4
|
|
)
|
|
row["sector_limit_count"] = limit_count
|
|
row["sector_up_count"] = up_count
|
|
row["sector_breadth_ma20"] = round(breadth_ma20, 1)
|
|
row["relative_strength"] = round(row["return_5d"] - market_return, 2)
|
|
sector_momentum_ranks = _percentile_map(
|
|
sector_metrics, "sector_return_20d", "desc"
|
|
)
|
|
sector_flow_ranks = _percentile_map(
|
|
sector_metrics, "sector_net_flow_5d_million", "desc"
|
|
)
|
|
sector_prosperity_ranks = _percentile_map(
|
|
sector_metrics, "sector_prosperity_raw", "desc"
|
|
)
|
|
sector_trend_ranks = _percentile_map(
|
|
sector_metrics, "sector_trend_raw", "desc"
|
|
)
|
|
sector_crowding_ranks = _percentile_map(
|
|
sector_metrics, "sector_crowding_raw", "desc"
|
|
)
|
|
for sector_name, sector_rows in sectors.items():
|
|
prosperity_rank = sector_prosperity_ranks.get(sector_name, 0.0)
|
|
trend_rank = sector_trend_ranks.get(sector_name, 0.0)
|
|
crowding_rank = sector_crowding_ranks.get(sector_name, 0.0)
|
|
composite_score = (
|
|
prosperity_rank * 0.40 + trend_rank * 0.30 + (1 - crowding_rank) * 0.30
|
|
)
|
|
for row in sector_rows:
|
|
row["sector_momentum_rank"] = round(
|
|
sector_momentum_ranks.get(sector_name, 0.0), 4
|
|
)
|
|
row["sector_flow_rank"] = round(
|
|
sector_flow_ranks.get(sector_name, 0.0), 4
|
|
)
|
|
row["sector_prosperity_rank"] = round(prosperity_rank, 4)
|
|
row["sector_trend_rank"] = round(trend_rank, 4)
|
|
row["sector_crowding_rank"] = round(crowding_rank, 4)
|
|
row["sector_composite_score"] = round(composite_score, 4)
|
|
|
|
factor_specs = {
|
|
"factor_value_score": (("pe_ttm", "asc"), ("pb", "asc"), ("dividend_yield_ttm", "desc")),
|
|
"factor_growth_score": (("revenue_yoy", "desc"), ("netprofit_yoy", "desc")),
|
|
"factor_quality_score": (("roe", "desc"), ("roic", "desc"), ("gross_margin", "desc")),
|
|
"factor_momentum_score": (("momentum_60_5", "desc"), ("relative_strength", "desc")),
|
|
"factor_sentiment_score": (("turnover_rate", "desc"), ("volume_ratio_5d", "desc")),
|
|
}
|
|
for output_field, specs in factor_specs.items():
|
|
maps = [_available_percentile_map(factors, field, direction) for field, direction in specs]
|
|
for row in factors:
|
|
values = [mapping.get(row["ts_code"]) for mapping in maps]
|
|
available = [value for value in values if value is not None]
|
|
row[output_field] = round(statistics.fmean(available), 4) if available else None
|
|
|
|
return_rank_map = _available_percentile_map(factors, "return_20d", "desc")
|
|
factor_weights = {}
|
|
for output_field in factor_specs:
|
|
pairs = [
|
|
(row.get(output_field), return_rank_map.get(row["ts_code"]))
|
|
for row in factors
|
|
if row.get(output_field) is not None and return_rank_map.get(row["ts_code"]) is not None
|
|
]
|
|
correlation = _pearson([pair[0] for pair in pairs], [pair[1] for pair in pairs])
|
|
factor_weights[output_field] = max(0.05, correlation)
|
|
factor_weight_total = sum(factor_weights.values()) or 1
|
|
for row in factors:
|
|
weighted = [
|
|
(row.get(field), weight)
|
|
for field, weight in factor_weights.items()
|
|
if row.get(field) is not None
|
|
]
|
|
row["multi_factor_composite"] = round(
|
|
sum(value * weight for value, weight in weighted)
|
|
/ (sum(weight for _, weight in weighted) or factor_weight_total),
|
|
4,
|
|
) if weighted else None
|
|
|
|
size_ranks = _available_percentile_map(factors, "total_mv_billion", "desc")
|
|
large_rows = [row for row in factors if (size_ranks.get(row["ts_code"]) or 0) >= 0.70]
|
|
small_rows = [
|
|
row for row in factors
|
|
if size_ranks.get(row["ts_code"]) is not None
|
|
and size_ranks[row["ts_code"]] <= 0.30
|
|
]
|
|
large_return = statistics.fmean(row["return_20d"] for row in large_rows) if large_rows else 0
|
|
small_return = statistics.fmean(row["return_20d"] for row in small_rows) if small_rows else 0
|
|
prefer_large = large_return >= small_return
|
|
growth_rows = [row for row in factors if (row.get("factor_growth_score") or 0) >= 0.70]
|
|
value_rows = [row for row in factors if (row.get("factor_value_score") or 0) >= 0.70]
|
|
growth_return = statistics.fmean(row["return_20d"] for row in growth_rows) if growth_rows else 0
|
|
value_return = statistics.fmean(row["return_20d"] for row in value_rows) if value_rows else 0
|
|
prefer_growth = growth_return >= value_return
|
|
for row in factors:
|
|
size_rank = size_ranks.get(row["ts_code"])
|
|
row["style_size_fit"] = round(
|
|
size_rank if prefer_large else 1 - size_rank, 4
|
|
) if size_rank is not None else None
|
|
style_factor = "factor_growth_score" if prefer_growth else "factor_value_score"
|
|
row["style_growth_fit"] = row.get(style_factor)
|
|
style_values = [
|
|
value for value in (row.get("style_size_fit"), row.get("style_growth_fit"))
|
|
if value is not None
|
|
]
|
|
row["style_fit_score"] = round(statistics.fmean(style_values), 4) if style_values else None
|
|
momentum_ranks = _percentile_map(factors, "momentum_60_5", "desc")
|
|
return_ranks = _percentile_map(factors, "return_5d", "desc")
|
|
market_height = max((int(row.get("limit_streak") or 0) for row in factors), default=0)
|
|
prior_market_height = max((int(row.get("prior_limit_streak") or 0) for row in factors), default=0)
|
|
for row in factors:
|
|
row["momentum_60_5_rank"] = round(momentum_ranks.get(row["ts_code"], 0.0), 4)
|
|
row["return_5d_rank"] = round(return_ranks.get(row["ts_code"], 0.0), 4)
|
|
is_height = market_height >= 2 and int(row.get("limit_streak") or 0) == market_height
|
|
row["is_market_height"] = int(is_height)
|
|
row["new_space_board"] = int(
|
|
is_height
|
|
and not (
|
|
prior_market_height >= 2
|
|
and int(row.get("prior_limit_streak") or 0) == prior_market_height
|
|
)
|
|
)
|
|
return factors, actual_date
|