rebuild(stage-9): deliver deterministic intelligent screening
This commit is contained in:
leefer
@@ -0,0 +1,272 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
from typing import Any
|
||||
|
||||
from backend.data.contracts import ProviderResult
|
||||
from backend.data.repository import MarketRepository
|
||||
from backend.database.connection import Database
|
||||
|
||||
|
||||
def assemble_screener_inputs(
|
||||
database: Database,
|
||||
repository: MarketRepository,
|
||||
trade_date: str,
|
||||
trade_dates: tuple[str, ...],
|
||||
raw: dict[str, ProviderResult | None],
|
||||
) -> tuple[dict[str, Any], dict[str, float]]:
|
||||
inputs = {
|
||||
key: [_normalize_row(row) for row in value.rows]
|
||||
for key, value in raw.items()
|
||||
if isinstance(value, ProviderResult)
|
||||
}
|
||||
inputs["earnings"] = _earnings_events(
|
||||
inputs.pop("forecast", []), inputs.pop("express", []), trade_date
|
||||
)
|
||||
popularity, popularity_coverage = _popularity(database, repository, trade_date)
|
||||
institutions, institution_coverage = _institutions(database, repository, trade_date)
|
||||
local_limits, local_limit_coverage = _local_limit_events(
|
||||
database, repository, trade_dates[-80:]
|
||||
)
|
||||
inputs["popularity"] = popularity
|
||||
inputs["institutions"] = institutions
|
||||
inputs["limit_events"] = _merge_events(inputs.get("limit_events", []), local_limits)
|
||||
|
||||
directory_count = len(inputs.get("directory", []))
|
||||
daily_current = _on_date(inputs.get("daily", []), trade_date)
|
||||
current_count = len({str(row.get("ts_code") or "") for row in daily_current})
|
||||
expected = max(directory_count, current_count, 1)
|
||||
basic_current = _on_date(inputs.get("daily_basic", []), trade_date)
|
||||
fundamentals = _latest_announced(inputs.get("fundamentals", []), trade_date)
|
||||
moneyflow_counts = _code_date_counts(inputs.get("moneyflow", []))
|
||||
industry_codes = {
|
||||
str(row.get("ts_code") or "")
|
||||
for row in inputs.get("industry", [])
|
||||
if _active_member(row, trade_date)
|
||||
}
|
||||
auction_count = len({str(row.get("ts_code") or "") for row in inputs.get("auction", [])})
|
||||
limit_result = raw.get("limit_events")
|
||||
provider_limit_coverage = (
|
||||
limit_result.metadata.coverage if isinstance(limit_result, ProviderResult) else 0
|
||||
)
|
||||
forecast = raw.get("forecast")
|
||||
express = raw.get("express")
|
||||
earnings_coverage = min(
|
||||
forecast.metadata.coverage if isinstance(forecast, ProviderResult) else 0,
|
||||
express.metadata.coverage if isinstance(express, ProviderResult) else 0,
|
||||
)
|
||||
coverage = {
|
||||
"market": min(current_count / expected, 1),
|
||||
"valuation": min(
|
||||
len({str(row.get("ts_code") or "") for row in basic_current}) / expected, 1
|
||||
),
|
||||
"financial": min(len(fundamentals) / expected, 1),
|
||||
"moneyflow": min(
|
||||
sum(count >= min(5, len(trade_dates)) for count in moneyflow_counts.values())
|
||||
/ expected,
|
||||
1,
|
||||
),
|
||||
"industry": min(len(industry_codes) / expected, 1),
|
||||
"auction": min(auction_count / expected, 1),
|
||||
"popularity": popularity_coverage,
|
||||
"institutions": institution_coverage,
|
||||
"earnings": earnings_coverage,
|
||||
"limit_events": max(provider_limit_coverage, local_limit_coverage),
|
||||
}
|
||||
return inputs, coverage
|
||||
|
||||
|
||||
def _popularity(
|
||||
database: Database, repository: MarketRepository, trade_date: str
|
||||
) -> tuple[list[dict[str, Any]], float]:
|
||||
with database.read() as connection:
|
||||
row = repository.insight_snapshot(connection, "popularity", trade_date)
|
||||
if row is None:
|
||||
return [], 0.0
|
||||
payload = json.loads(str(row["payload_json"]))
|
||||
return [
|
||||
{
|
||||
"ts_code": str(item.get("identifier") or ""),
|
||||
"combined_score": item.get("score"),
|
||||
"rank_change": item.get("rank_change"),
|
||||
"dual_source": bool(item.get("dual_source")),
|
||||
}
|
||||
for item in payload.get("combined") or []
|
||||
if item.get("identifier")
|
||||
], float(row["coverage"])
|
||||
|
||||
|
||||
def _institutions(
|
||||
database: Database, repository: MarketRepository, trade_date: str
|
||||
) -> tuple[list[dict[str, Any]], float]:
|
||||
with database.read() as connection:
|
||||
row = repository.insight_snapshot(connection, "dragon-list", trade_date)
|
||||
if row is None:
|
||||
return [], 0.0
|
||||
payload = json.loads(str(row["payload_json"]))
|
||||
seats = payload.get("seats")
|
||||
if seats is None:
|
||||
return [], 0.0
|
||||
grouped: dict[str, dict[str, float]] = {}
|
||||
for item in seats:
|
||||
identifier = str(item.get("ts_code") or "")
|
||||
if not identifier or "机构" not in str(item.get("exalter") or ""):
|
||||
continue
|
||||
target = grouped.setdefault(identifier, {"net": 0.0, "count": 0})
|
||||
target["net"] += float(item.get("net_buy") or 0) / 1_000_000
|
||||
target["count"] += 1
|
||||
return [
|
||||
{
|
||||
"ts_code": identifier,
|
||||
"net_buy_million": values["net"],
|
||||
"seat_count": int(values["count"]),
|
||||
}
|
||||
for identifier, values in grouped.items()
|
||||
], float(row["coverage"])
|
||||
|
||||
|
||||
def _local_limit_events(
|
||||
database: Database,
|
||||
repository: MarketRepository,
|
||||
trade_dates: tuple[str, ...],
|
||||
) -> tuple[list[dict[str, Any]], float]:
|
||||
if not trade_dates:
|
||||
return [], 0.0
|
||||
with database.read() as connection:
|
||||
rows = repository.summaries(connection, trade_dates[-1], len(trade_dates))
|
||||
expected = set(trade_dates)
|
||||
covered: set[str] = set()
|
||||
events = []
|
||||
for row in rows:
|
||||
trade_date = str(row["trade_date"])
|
||||
if trade_date not in expected:
|
||||
continue
|
||||
covered.add(trade_date)
|
||||
payload = json.loads(str(row["payload_json"]))
|
||||
for key, event in (("limits", "U"), ("broken", "Z"), ("down_limits", "D")):
|
||||
events.extend(
|
||||
{
|
||||
"trade_date": trade_date,
|
||||
"ts_code": str(item["identifier"]),
|
||||
"limit_type": event,
|
||||
}
|
||||
for item in payload.get(key) or []
|
||||
if item.get("identifier")
|
||||
)
|
||||
return events, len(covered) / len(expected)
|
||||
|
||||
|
||||
def _normalize_row(row: dict[str, Any]) -> dict[str, Any]:
|
||||
result = dict(row)
|
||||
for field in ("trade_date", "ann_date", "end_date", "ex_date", "in_date", "out_date"):
|
||||
value = str(result.get(field) or "")
|
||||
if len(value) == 8 and value.isdigit():
|
||||
result[field] = f"{value[:4]}-{value[4:6]}-{value[6:]}"
|
||||
if result.get("price") is not None and result.get("pre_close") is not None:
|
||||
price = _number(result.get("price"))
|
||||
previous = _number(result.get("pre_close"))
|
||||
result["change"] = (price / previous - 1) * 100 if price is not None and previous else None
|
||||
amount = _number(result.get("amount"))
|
||||
result["amount_million"] = amount / 1_000_000 if amount is not None else None
|
||||
return result
|
||||
|
||||
|
||||
def _earnings_events(
|
||||
forecasts: list[dict[str, Any]], expresses: list[dict[str, Any]], through: str
|
||||
) -> list[dict[str, Any]]:
|
||||
forecast_map: dict[tuple[str, str], dict[str, Any]] = {}
|
||||
for row in forecasts:
|
||||
key = (str(row.get("ts_code") or ""), str(row.get("end_date") or ""))
|
||||
announced = str(row.get("ann_date") or "")
|
||||
current = forecast_map.get(key)
|
||||
if (
|
||||
all(key)
|
||||
and announced
|
||||
and announced <= through
|
||||
and (current is None or announced > str(current.get("ann_date") or ""))
|
||||
):
|
||||
forecast_map[key] = row
|
||||
result = []
|
||||
for row in expresses:
|
||||
key = (str(row.get("ts_code") or ""), str(row.get("end_date") or ""))
|
||||
announced = str(row.get("ann_date") or "")
|
||||
forecast = forecast_map.get(key)
|
||||
if forecast is None or not announced or announced > through:
|
||||
continue
|
||||
values = [
|
||||
value
|
||||
for value in (
|
||||
_number(forecast.get("net_profit_min")),
|
||||
_number(forecast.get("net_profit_max")),
|
||||
)
|
||||
if value is not None
|
||||
]
|
||||
expected = sum(values) / len(values) if values else None
|
||||
actual = _number(row.get("n_income"))
|
||||
if expected in (None, 0) or actual is None:
|
||||
continue
|
||||
if abs(actual) > max(abs(expected), 1) * 100:
|
||||
actual /= 10000
|
||||
result.append(
|
||||
{
|
||||
"ts_code": key[0],
|
||||
"end_date": key[1],
|
||||
"ann_date": announced,
|
||||
"surprise_pct": (actual / expected - 1) * 100,
|
||||
}
|
||||
)
|
||||
return result
|
||||
|
||||
|
||||
def _on_date(rows: list[dict[str, Any]], trade_date: str) -> list[dict[str, Any]]:
|
||||
return [row for row in rows if str(row.get("trade_date") or "") == trade_date]
|
||||
|
||||
|
||||
def _latest_announced(rows: list[dict[str, Any]], through: str) -> dict[str, dict[str, Any]]:
|
||||
result: dict[str, dict[str, Any]] = {}
|
||||
for row in rows:
|
||||
identifier = str(row.get("ts_code") or "")
|
||||
announced = str(row.get("ann_date") or "")
|
||||
current = result.get(identifier)
|
||||
if (
|
||||
identifier
|
||||
and announced
|
||||
and announced <= through
|
||||
and (current is None or announced > str(current.get("ann_date") or ""))
|
||||
):
|
||||
result[identifier] = row
|
||||
return result
|
||||
|
||||
|
||||
def _code_date_counts(rows: list[dict[str, Any]]) -> dict[str, int]:
|
||||
values: dict[str, set[str]] = {}
|
||||
for row in rows:
|
||||
identifier = str(row.get("ts_code") or "")
|
||||
if identifier:
|
||||
values.setdefault(identifier, set()).add(str(row.get("trade_date") or ""))
|
||||
return {identifier: len(dates) for identifier, dates in values.items()}
|
||||
|
||||
|
||||
def _active_member(row: dict[str, Any], trade_date: str) -> bool:
|
||||
start = str(row.get("in_date") or "")
|
||||
end = str(row.get("out_date") or "")
|
||||
return (not start or start <= trade_date) and (not end or end > trade_date)
|
||||
|
||||
|
||||
def _merge_events(
|
||||
provider: list[dict[str, Any]], local: list[dict[str, Any]]
|
||||
) -> list[dict[str, Any]]:
|
||||
merged = {
|
||||
(str(row.get("trade_date") or ""), str(row.get("ts_code") or "")): row for row in local
|
||||
}
|
||||
for row in provider:
|
||||
merged[(str(row.get("trade_date") or ""), str(row.get("ts_code") or ""))] = row
|
||||
return list(merged.values())
|
||||
|
||||
|
||||
def _number(value: Any) -> float | None:
|
||||
try:
|
||||
result = float(value)
|
||||
return result if result == result else None
|
||||
except (TypeError, ValueError):
|
||||
return None
|
||||
Reference in New Issue
Block a user