174 lines
9.4 KiB
Python
174 lines
9.4 KiB
Python
"""Deterministic liquid-leader scanner and local-LLM handoff JSON."""
|
|
|
|
from __future__ import annotations
|
|
|
|
from dataclasses import dataclass
|
|
import json
|
|
from pathlib import Path
|
|
|
|
import numpy as np
|
|
import pandas as pd
|
|
|
|
from .config import AppConfig, StrategyConfig
|
|
from .portfolio import size_position
|
|
from .setups import DEFAULT_SCORE_WEIGHTS, focus_score, setup_for
|
|
|
|
|
|
@dataclass
|
|
class ScanResult:
|
|
market_summary: dict[str, object]
|
|
candidates: pd.DataFrame
|
|
|
|
def ai_payload(self, *, portfolio_heat: float = 0.0, portfolio_cushion: float = 0.0) -> list[dict[str, object]]:
|
|
payload = []
|
|
for row in self.candidates.to_dict("records"):
|
|
payload.append({
|
|
"ticker": row["ticker"], "market_regime": str(self.market_summary["regime"]).lower(),
|
|
"rs_percentile": row["rs"], "structure": str(row["structure"]).lower(),
|
|
"rs_1m": row["rs_1m"], "rs_3m": row["rs_3m"], "rs_12m": row["rs_12m"],
|
|
"rs_1m_vs_set": row["rs_1m_vs_set"], "rs_3m_vs_set": row["rs_3m_vs_set"],
|
|
"rs_12m_vs_set": row["rs_12m_vs_set"],
|
|
"rs_1m_vs_set100ew": row["rs_1m_vs_set100ew"],
|
|
"rs_3m_vs_set100ew": row["rs_3m_vs_set100ew"],
|
|
"rs_12m_vs_set100ew": row["rs_12m_vs_set100ew"],
|
|
"52w_proximity_pct": row["52w_proximity_pct"],
|
|
"distance_atr": row["atr_distance"], "higher_low": row["higher_low"],
|
|
"volume_contracting": row["volume_contracting"], "weekly_confluence": row["weekly_confluence"],
|
|
"entry_type": row["entry_type"], "portfolio_heat": portfolio_heat,
|
|
"portfolio_cushion": portfolio_cushion, "focus_score": row["score"],
|
|
"reasons": row["reasons"], "sector": row.get("sector"),
|
|
})
|
|
return payload
|
|
|
|
def write_json(self, path: str | Path, **portfolio_state: float) -> None:
|
|
Path(path).write_text(json.dumps(self.ai_payload(**portfolio_state), indent=2, ensure_ascii=False), encoding="utf-8")
|
|
|
|
|
|
def scan_candidates(features_by_symbol: dict[str, pd.DataFrame], market: pd.DataFrame, *,
|
|
config: AppConfig | None = None, top_n: int = 10,
|
|
score_weights: dict[str, float] | None = None,
|
|
sectors: dict[str, str] | None = None,
|
|
equity: float | None = None) -> ScanResult:
|
|
if top_n < 1:
|
|
raise ValueError("top_n must be positive")
|
|
config = config or AppConfig()
|
|
strategy: StrategyConfig = config.strategy
|
|
sectors = sectors or {}
|
|
weights = score_weights or config.focus_weights or DEFAULT_SCORE_WEIGHTS
|
|
if market.empty:
|
|
market_row = pd.Series(dtype=object)
|
|
date = None
|
|
else:
|
|
market_row = market.iloc[-1]
|
|
date = market.index[-1]
|
|
members_by_date = market.attrs.get("members_by_date")
|
|
active_members = (set(members_by_date.get(pd.Timestamp(date), []))
|
|
if members_by_date is not None and date is not None else None)
|
|
regime = str(market_row.get("regime", "UNKNOWN"))
|
|
market_flag = market_row.get("new_risk_allowed", False)
|
|
market_allows_new_risk = pd.notna(market_flag) and bool(market_flag)
|
|
blocked_regimes = {"CORRECTION", "BREAKDOWN", "OVERBOUGHT"}
|
|
summary = {
|
|
"date": date.date().isoformat() if date is not None else None,
|
|
"set_trend": market_row.get("trend_state", "UNKNOWN"),
|
|
"set100ew_trend": market_row.get("ew_trend_state", "UNKNOWN"),
|
|
"mco": float(market_row["mco"]) if pd.notna(market_row.get("mco", np.nan)) else None,
|
|
"mco_z": float(market_row["mco_z"]) if pd.notna(market_row.get("mco_z", np.nan)) else None,
|
|
"mcsi_state": market_row.get("mcsi_state", "UNKNOWN"),
|
|
"breadth": {"advancing": int(market_row.get("advancing", 0) or 0),
|
|
"declining": int(market_row.get("declining", 0) or 0),
|
|
"unchanged": int(market_row.get("unchanged", 0) or 0),
|
|
"net_advances": int(market_row.get("net_advances", 0) or 0)},
|
|
"regime": regime, "reasons": market_row.get("regime_reasons", []),
|
|
"new_risk": "ALLOWED" if market_allows_new_risk and regime not in blocked_regimes else "BLOCKED",
|
|
}
|
|
latest_rows: dict[str, pd.Series] = {}
|
|
candidate_frames: dict[str, pd.DataFrame] = {}
|
|
for symbol, frame in features_by_symbol.items():
|
|
if active_members is not None and symbol not in active_members:
|
|
continue
|
|
if date is not None:
|
|
frame = frame.loc[frame.index <= date]
|
|
frame = frame.dropna(subset=["close"])
|
|
if frame.empty or (date is not None and pd.Timestamp(frame.index[-1]) != pd.Timestamp(date)):
|
|
continue
|
|
latest = frame.iloc[-1]
|
|
avg_turnover = latest.get("avg_value_turnover20", np.nan)
|
|
rs = latest.get("rs_percentile", np.nan)
|
|
if pd.isna(avg_turnover) or avg_turnover < strategy.min_value_turnover_thb:
|
|
continue
|
|
if latest["close"] < strategy.min_price or pd.isna(rs):
|
|
continue
|
|
if strategy.enable_rs and rs < strategy.min_rs_percentile:
|
|
continue
|
|
latest_rows[symbol] = latest
|
|
candidate_frames[symbol] = frame
|
|
sector_scores: dict[str, float] = {}
|
|
grouped: dict[str, list[float]] = {}
|
|
for symbol, row in latest_rows.items():
|
|
sector = sectors.get(symbol)
|
|
if sector:
|
|
grouped.setdefault(sector, []).append(float(row.get("rs_percentile", 0) or 0))
|
|
sector_scores = {sector: float(np.mean(values)) for sector, values in grouped.items()}
|
|
rows = []
|
|
market_blocks_new_risk = (strategy.require_market_support and strategy.enable_market_regime
|
|
and (not market_allows_new_risk or regime in blocked_regimes))
|
|
for symbol, row in latest_rows.items():
|
|
frame = candidate_frames[symbol]
|
|
previous = frame.iloc[-2] if len(frame) > 1 else None
|
|
prior_high = None
|
|
if len(frame) > strategy.base_breakout_window:
|
|
prior_high = float(frame["high"].iloc[-strategy.base_breakout_window - 1:-1].max())
|
|
setup, entry, stop = setup_for(
|
|
row, previous, prior_high=prior_high,
|
|
max_extension_atr=strategy.max_extension_atr)
|
|
if market_blocks_new_risk:
|
|
setup, entry, stop = None, None, None
|
|
sector = sectors.get(symbol)
|
|
sector_strength = sector_scores.get(sector) if sector else None
|
|
score = focus_score(row, sector_strength=sector_strength, weights=weights)
|
|
proposed_entry = float(entry if entry is not None else row["close"])
|
|
proposed_stop = float(stop if stop is not None else row.get("ema21_low", np.nan))
|
|
risk_pct = (strategy.weakness_risk_pct if setup == "21DMA Retest"
|
|
else strategy.confirmation_risk_pct if setup else 0.0)
|
|
size = size_position(equity or strategy.initial_equity, risk_pct, proposed_entry, proposed_stop,
|
|
lot_size=config.market_rules.default_board_lot,
|
|
max_position_pct=strategy.max_position_pct, rules=config.market_rules)
|
|
entry_type = "WEAKNESS" if setup == "21DMA Retest" else "CONFIRMATION" if setup else "WATCH"
|
|
reasons = []
|
|
if row.get("trend_state") == "UP":
|
|
reasons.append("21DMA structure rising")
|
|
if bool(row.get("higher_low", False)):
|
|
reasons.append("confirmed higher low")
|
|
if bool(row.get("volume_contracting", False)):
|
|
reasons.append("pullback volume contracting")
|
|
if row.get("weekly_trend_state") == "UP":
|
|
reasons.append("weekly structure rising")
|
|
if setup:
|
|
reasons.append(setup)
|
|
if market_blocks_new_risk:
|
|
reasons.append("market regime blocks new entries")
|
|
rows.append({
|
|
"ticker": symbol, "score": score, "rs": round(float(row["rs_percentile"]), 2),
|
|
"rs_1m": row.get("rs_1m"), "rs_3m": row.get("rs_3m"), "rs_12m": row.get("rs_12m"),
|
|
"rs_1m_vs_set": row.get("rs_1m_vs_set"), "rs_3m_vs_set": row.get("rs_3m_vs_set"),
|
|
"rs_12m_vs_set": row.get("rs_12m_vs_set"),
|
|
"rs_1m_vs_set100ew": row.get("rs_1m_vs_set100ew"),
|
|
"rs_3m_vs_set100ew": row.get("rs_3m_vs_set100ew"),
|
|
"rs_12m_vs_set100ew": row.get("rs_12m_vs_set100ew"),
|
|
"52w_proximity_pct": row.get("52w_proximity_pct"),
|
|
"atr_distance": round(float(row.get("extension_atr", np.nan)), 2) if pd.notna(row.get("extension_atr", np.nan)) else None,
|
|
"structure": row.get("trend_state", "NEUTRAL"), "higher_low": bool(row.get("higher_low", False)),
|
|
"volume_contracting": bool(row.get("volume_contracting", False)),
|
|
"weekly_confluence": row.get("weekly_trend_state") == "UP", "setup": setup or "Watch",
|
|
"entry_type": entry_type, "entry": proposed_entry, "stop": proposed_stop,
|
|
"initial_R": proposed_entry - proposed_stop if proposed_entry > proposed_stop else None,
|
|
"risk_pct": risk_pct, "shares": int(size["shares"]), "position_value_thb": size["position_value"],
|
|
"sector": sector, "sector_strength": sector_strength,
|
|
"avg_value_turnover_thb": float(row["avg_value_turnover20"]), "reasons": reasons,
|
|
})
|
|
candidates = pd.DataFrame(rows)
|
|
if not candidates.empty:
|
|
candidates = candidates.sort_values(["score", "rs", "avg_value_turnover_thb"], ascending=False).head(top_n).reset_index(drop=True)
|
|
return ScanResult(summary, candidates)
|