aria-code 4.1.3__py3-none-any.whl

agents/financial/sector.py

@@ -0,0 +1,279 @@
+"""
+agents/financial/sector.py — 行业轮动分析 Agent
+================================================
+分析标的所属行业的相对强弱：行业指数表现、资金流入/流出趋势、
+板块轮动阶段，以判断标的是否处于顺风还是逆风环境。
+数据源：yfinance 行业 ETF（XLK/XLF/XLE/…）+ akshare 行业指数（A股）
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Dict, List, Optional
+
+from ..base import BaseAgent, AgentResult
+
+logger = logging.getLogger(__name__)
+
+# 美股行业 ETF 映射 (GICS Sectors)
+_US_SECTOR_ETFS: Dict[str, str] = {
+    "Technology":             "XLK",
+    "Health Care":            "XLV",
+    "Financials":             "XLF",
+    "Consumer Discretionary": "XLY",
+    "Consumer Staples":       "XLP",
+    "Industrials":            "XLI",
+    "Energy":                 "XLE",
+    "Materials":              "XLB",
+    "Real Estate":            "XLRE",
+    "Utilities":              "XLU",
+    "Communication Services": "XLC",
+}
+
+# 默认参考基准
+_BENCHMARK = "SPY"
+
+
+class SectorAgent(BaseAgent):
+
+    name        = "sector"
+    description = "行业轮动 — 所属板块相对强弱、资金流入/流出趋势"
+
+    _SYSTEM = (
+        "You are a sector rotation analyst. Given a stock and its sector's "
+        "recent performance relative to the broader market, assess:\n"
+        "1. Is the sector in an uptrend or downtrend vs the S&P 500?\n"
+        "2. Is money flowing INTO or OUT OF this sector recently?\n"
+        "3. What stage of the sector rotation cycle is this sector in "
+        "(early/mid/late recovery, contraction)?\n"
+        "4. Does the sector tailwind/headwind support BUY/HOLD/SELL on the stock?\n"
+        "Conclude: TAILWIND (sector supports bullish) / NEUTRAL / HEADWIND (sector drags bearish)"
+    )
+
+    async def fetch_data(self, symbol: str) -> Dict[str, Any]:
+        data = await super().fetch_data(symbol)
+        sector_data: Dict[str, Any] = {}
+
+        try:
+            import yfinance as yf
+            ticker = yf.Ticker(symbol)
+
+            # 1. Identify sector from stock info
+            info   = ticker.info or {}
+            sector = info.get("sector", "")
+            industry = info.get("industry", "")
+            sector_data["sector"]   = sector
+            sector_data["industry"] = industry
+
+            # 2. Get sector ETF for US stocks
+            etf_sym = _US_SECTOR_ETFS.get(sector)
+            if not etf_sym:
+                # Try to guess from ticker pattern for A-shares
+                if _is_a_share(symbol):
+                    sector_data["market"] = "CN"
+                    sector_data["etf_sym"] = None
+                else:
+                    sector_data["market"] = "US"
+                    sector_data["etf_sym"] = None
+            else:
+                sector_data["etf_sym"] = etf_sym
+                sector_data["market"] = "US"
+
+            # 3. Fetch returns for sector ETF and benchmark
+            comparisons: Dict[str, Dict] = {}
+            for periods in [("1mo", 21), ("3mo", 63), ("6mo", 126)]:
+                period_key, _ = periods[0], periods[1]
+                comparisons[period_key] = {}
+
+            syms_to_fetch = [_BENCHMARK]
+            if etf_sym:
+                syms_to_fetch.append(etf_sym)
+
+            for fetch_sym in syms_to_fetch:
+                try:
+                    hist = yf.Ticker(fetch_sym).history(period="6mo")
+                    if hist.empty:
+                        continue
+                    close = hist["Close"]
+                    for period_key, days in [("1mo", 21), ("3mo", 63), ("6mo", len(close))]:
+                        if len(close) >= days:
+                            ret = (float(close.iloc[-1]) - float(close.iloc[-days])) / float(close.iloc[-days])
+                            comparisons[period_key][fetch_sym] = round(ret * 100, 2)
+                except Exception as e:
+                    logger.debug("[sector] fetch %s: %s", fetch_sym, e)
+
+            sector_data["comparisons"] = comparisons
+
+            # 4. Stock's own recent performance vs sector
+            try:
+                hist = ticker.history(period="3mo")
+                if not hist.empty and len(hist) >= 21:
+                    close = hist["Close"]
+                    stock_1mo = (float(close.iloc[-1]) - float(close.iloc[-21])) / float(close.iloc[-21]) * 100
+                    sector_data["stock_1mo_return"] = round(stock_1mo, 2)
+            except Exception as e:
+                logger.debug("[sector] stock return %s: %s", symbol, e)
+
+            # 5. A-share sector data via akshare
+            if _is_a_share(symbol):
+                try:
+                    import akshare as ak
+                    sector_df = ak.stock_board_industry_name_em()
+                    if sector_df is not None and not sector_df.empty:
+                        sector_data["cn_sectors_available"] = True
+                except Exception:
+                    pass
+
+        except Exception as e:
+            logger.debug("[sector] yfinance init %s: %s", symbol, e)
+
+        data["sector_data"] = sector_data
+        return data
+
+    async def analyze(self, symbol: str, data: Dict[str, Any]) -> AgentResult:
+        sd    = data.get("sector_data", {})
+        quote = data.get("quote", {})
+        price = quote.get("price", 0)
+
+        if not sd:
+            return AgentResult(
+                agent=self.name, symbol=symbol,
+                analysis=f"{symbol}: 未获取到行业数据。",
+                confidence=0.3, signal="HOLD",
+                key_points=["无行业数据"],
+            )
+
+        sector_block = _format_sector_stats(sd)
+        rel_strength = _compute_relative_strength(sd)
+
+        prompt = (
+            f"Stock: {symbol}  Sector: {sd.get('sector', 'Unknown')}  "
+            f"Industry: {sd.get('industry', 'Unknown')}\n\n"
+            f"Sector Performance vs Market:\n{sector_block}\n\n"
+            f"Relative Strength Assessment: {rel_strength}\n\n"
+            "Analyze sector rotation dynamics and conclude:\n"
+            "TAILWIND / NEUTRAL / HEADWIND"
+        )
+
+        analysis = await self._call_llm(self._SYSTEM, prompt, max_tokens=450)
+        if not analysis:
+            analysis = _template_analysis(symbol, sd, rel_strength)
+
+        signal, confidence = _derive_signal(analysis, sd, rel_strength)
+        key_points         = _build_key_points(sd, rel_strength, signal)
+
+        return AgentResult(
+            agent=self.name, symbol=symbol,
+            analysis=analysis,
+            confidence=confidence,
+            signal=signal,
+            key_points=key_points,
+            data_used={
+                "sector": sd.get("sector"),
+                "etf": sd.get("etf_sym"),
+                "rel_strength": rel_strength,
+            },
+        )
+
+
+# ── Helpers ───────────────────────────────────────────────────────────────────
+
+def _is_a_share(symbol: str) -> bool:
+    import re
+    return bool(re.match(r"^[036]\d{5}$", symbol))
+
+
+def _format_sector_stats(sd: Dict) -> str:
+    lines = []
+    sector  = sd.get("sector", "Unknown")
+    etf_sym = sd.get("etf_sym", "")
+    comps   = sd.get("comparisons", {})
+    lines.append(f"Sector: {sector}{f'  ETF: {etf_sym}' if etf_sym else ''}")
+
+    if comps:
+        lines.append(f"\n{'Period':<8} {'SPY':>8} {etf_sym or 'SECTOR':>8}  Rel.Strength")
+        for period in ("1mo", "3mo", "6mo"):
+            c = comps.get(period, {})
+            spy = c.get(_BENCHMARK)
+            etf = c.get(etf_sym) if etf_sym else None
+            spy_str = f"{spy:+.1f}%" if spy is not None else "  N/A"
+            etf_str = f"{etf:+.1f}%" if etf is not None else "  N/A"
+            rel = ""
+            if spy is not None and etf is not None:
+                diff = etf - spy
+                rel  = f"{diff:+.1f}% vs SPY"
+            lines.append(f"{period:<8} {spy_str:>8} {etf_str:>8}  {rel}")
+
+    stock_1mo = sd.get("stock_1mo_return")
+    if stock_1mo is not None:
+        lines.append(f"\nStock 1-month: {stock_1mo:+.1f}%")
+
+    return "\n".join(lines)
+
+
+def _compute_relative_strength(sd: Dict) -> str:
+    etf_sym = sd.get("etf_sym")
+    comps   = sd.get("comparisons", {})
+    if not etf_sym or not comps:
+        return "无法计算（无行业 ETF 数据）"
+
+    scores = []
+    for period in ("1mo", "3mo"):
+        c   = comps.get(period, {})
+        spy = c.get(_BENCHMARK)
+        etf = c.get(etf_sym)
+        if spy is not None and etf is not None:
+            scores.append(etf - spy)
+
+    if not scores:
+        return "数据不足"
+    avg_rs = sum(scores) / len(scores)
+    if avg_rs > 3:
+        return f"行业强于大盘 +{avg_rs:.1f}%（顺风）"
+    if avg_rs > 0:
+        return f"行业小幅跑赢 +{avg_rs:.1f}%（中性偏正）"
+    if avg_rs > -3:
+        return f"行业小幅落后 {avg_rs:.1f}%（中性偏负）"
+    return f"行业明显弱于大盘 {avg_rs:.1f}%（逆风）"
+
+
+def _derive_signal(analysis: str, sd: Dict, rel_str: str) -> tuple[str, float]:
+    text = analysis.upper()
+    if "TAILWIND" in text:
+        return "BUY", 0.55
+    if "HEADWIND" in text:
+        return "SELL", 0.55
+
+    # Fallback: use relative strength
+    if "顺风" in rel_str or "跑赢" in rel_str:
+        return "BUY", 0.45
+    if "逆风" in rel_str or "落后" in rel_str:
+        return "SELL", 0.45
+    return "HOLD", 0.40
+
+
+def _build_key_points(sd: Dict, rel_str: str, signal: str) -> List[str]:
+    pts = []
+    sec = sd.get("sector", "")
+    if sec:
+        pts.append(f"行业: {sec}")
+    etf = sd.get("etf_sym")
+    if etf:
+        pts.append(f"对应 ETF: {etf}")
+    pts.append(f"板块强弱: {rel_str[:40]}")
+    stock_1mo = sd.get("stock_1mo_return")
+    if stock_1mo is not None:
+        pts.append(f"个股1月涨跌: {stock_1mo:+.1f}%")
+    pts.append(f"行业信号: {signal}")
+    return pts[:5]
+
+
+def _template_analysis(symbol: str, sd: Dict, rel_str: str) -> str:
+    sector = sd.get("sector", "Unknown")
+    verdict = "TAILWIND" if "顺风" in rel_str else ("HEADWIND" if "逆风" in rel_str else "NEUTRAL")
+    return (
+        f"{symbol} 行业分析（模板）\n"
+        f"所属行业: {sector}\n"
+        f"行业强弱: {rel_str}\n"
+        f"结论: {verdict}"
+    )

agents/financial/synthesis.py

@@ -0,0 +1,274 @@
+"""
+agents/financial/synthesis.py — 综合汇总 Agent
+===============================================
+汇总所有 agent 结果，输出可操作的投资建议。
+加权规则：置信度平方作为权重，高置信度信号影响力更大。
+"""
+from __future__ import annotations
+from typing import Any, Dict, List
+from ..base import BaseAgent, AgentResult
+
+# 每个 agent 的基础重要性权重（反映信息价值，可在 .ariarc 中覆盖）
+_AGENT_WEIGHTS: Dict[str, float] = {
+    "technical":   1.2,   # 短期动量信息量最高
+    "fundamental": 1.1,   # 价值锚
+    "risk":        1.0,
+    "macro":       0.9,   # 宏观慢变量，不应过度主导短期判断
+    "news":        1.0,
+    "catalyst":    1.1,   # 催化剂改变时机，提高权重
+    "earnings":    1.1,
+    "sector":      0.8,
+    "debate":      0.5,   # 调解结果已融入其他 agent，避免重复计入
+}
+
+_SIGNAL_SCORE: Dict[str, float] = {
+    "STRONG_BUY":  2.0,
+    "BUY":         1.0,
+    "HOLD":        0.0,
+    "SELL":        -1.0,
+    "STRONG_SELL": -2.0,
+}
+
+
+class SynthesisAgent(BaseAgent):
+    name        = "synthesis"
+    description = "综合汇总：整合多 Agent 结论，输出操作建议（置信度加权投票）"
+
+    _SYSTEM = (
+        "You are the chief investment strategist. Synthesize analyses from "
+        "macro, fundamental, technical, and risk agents into a clear, "
+        "actionable investment recommendation. Be concise and direct. "
+        "End with: FINAL: BUY / HOLD / SELL (with target price and stop loss IF real data is available)."
+    )
+
+    async def analyze(self, symbol: str, data: Dict[str, Any]) -> AgentResult:
+        agent_results: List[Dict] = data.get("agent_results", [])
+        consensus_signal = str(data.get("consensus_signal") or "HOLD").upper()
+        consensus_conf = data.get("consensus_confidence")
+        consensus_conf_num = (
+            _safe_float(consensus_conf)
+            if consensus_conf is not None else _calc_weighted_confidence(agent_results)
+        )
+
+        # Check if any agent had real price data
+        _quote = data.get("quote", {})
+        _snapshot = data.get("market_snapshot", {}) or {}
+        _price = _snapshot.get("price") or (_quote.get("price", 0) if _quote else 0)
+        _data_available = bool(_safe_float(_price))
+        _market_block = data.get("market_data_block") or _format_market_block(data)
+        _target = _snapshot.get("analyst_target")
+        _stop = _risk_stop(_snapshot, _snapshot.get("currency") or "USD")
+
+        summary_parts = []
+        for r in agent_results:
+            if not r.get("error"):
+                agent_name = r["agent"].upper()
+                signal     = r.get("signal", "HOLD")
+                conf       = r.get("confidence", 0.5)
+                points     = r.get("key_points", [])
+                pts_str    = "; ".join(points[:2]) if points else r.get("analysis", "")[:80]
+                summary_parts.append(
+                    f"[{agent_name}] Signal={signal} ({conf:.0%}): {pts_str}"
+                )
+
+        summary = "\n".join(summary_parts) if summary_parts else "No agent data"
+
+        if _data_available:
+            _price_instruction = (
+                "3. Entry strategy using ONLY the supplied current price, MA20/MA60, RSI, MACD and analyst_target.\n"
+                "4. Target/stop rules: use analyst_target only if supplied; otherwise write Target: N/A (analyst target missing). "
+                "Use stated support first; use MA60 only when price is still above it. If price is already below MA60, call MA60 a recovery level, not a stop. Do not invent prices.\n"
+                f"FINAL: {consensus_signal} | Target: "
+                f"{'$' + str(_target) if _safe_float(_target) else 'N/A (analyst target missing)'} | "
+                f"Stop: {_stop}"
+            )
+        else:
+            _price_instruction = (
+                "3. Entry strategy qualitative only because current price is missing.\n"
+                "4. Do not give target or stop prices.\n"
+                f"FINAL: {consensus_signal} | Target: N/A (price missing) | Stop: N/A"
+            )
+
+        prompt = (
+            f"Symbol: {symbol}\n"
+            f"Consensus signal: {consensus_signal}\n"
+            f"Consensus confidence: {consensus_conf_num:.0%}\n"
+            f"Real price data available: {'YES — price=' + str(_price) if _data_available else 'NO — do not invent prices'}\n"
+            f"Verified market data:\n{_market_block}\n\n"
+            f"Agent Analyses:\n{summary}\n\n"
+            "Provide final recommendation:\n"
+            "1. Overall investment thesis (2-3 concise sentences, grounded in verified market data)\n"
+            "2. Key risks to monitor; separate structural risks from missing real-time risk data\n"
+            + _price_instruction
+        )
+
+        analysis  = await self._call_llm(self._SYSTEM, prompt, max_tokens=600, quote=_quote)
+        if not analysis:
+            analysis = _template_synthesis(symbol, agent_results, data)
+        elif _data_available:
+            analysis = (
+                analysis
+                .replace("N/A (no real data)", "N/A (analyst target missing)")
+                .replace("no real data", "analyst target missing")
+                .replace("信心 ≤40%", f"置信度 {consensus_conf_num:.0%}")
+            )
+
+        signal     = consensus_signal or _extract_final_signal(analysis)
+        confidence = consensus_conf_num
+        key_points = _extract_key_points(analysis)
+
+        return AgentResult(
+            agent=self.name, symbol=symbol,
+            analysis=analysis, confidence=confidence,
+            signal=signal, key_points=key_points,
+        )
+
+
+def _extract_final_signal(text: str) -> str:
+    import re
+    m = re.search(r"FINAL[:\s]+([A-Z_]+)", text.upper())
+    if m:
+        raw = m.group(1)
+        if "STRONG_BUY" in raw:  return "STRONG_BUY"
+        if "BUY" in raw:         return "BUY"
+        if "STRONG_SELL" in raw: return "STRONG_SELL"
+        if "SELL" in raw:        return "SELL"
+    return "HOLD"
+
+
+def _calc_weighted_confidence(results: List[Dict]) -> float:
+    """
+    Confidence = weighted average where weight = agent_base_weight × confidence².
+    High-confidence agents dominate; low-confidence agents contribute minimally.
+    """
+    valid = [r for r in results if not r.get("error")]
+    if not valid:
+        return 0.5
+    total_w, weighted_sum = 0.0, 0.0
+    for r in valid:
+        conf      = max(0.0, min(1.0, float(r.get("confidence", 0.5))))
+        base_w    = _AGENT_WEIGHTS.get(r.get("agent", ""), 1.0)
+        w         = base_w * (conf ** 2)          # confidence² amplifies strong signals
+        weighted_sum += conf * w
+        total_w      += w
+    return round(weighted_sum / total_w, 2) if total_w else 0.5
+
+
+def _calc_weighted_signal_score(results: List[Dict]) -> float:
+    """Weighted signal score used by the template fallback."""
+    valid = [r for r in results if not r.get("error")]
+    if not valid:
+        return 0.0
+    total_w, score_sum = 0.0, 0.0
+    for r in valid:
+        conf   = max(0.0, min(1.0, float(r.get("confidence", 0.5))))
+        base_w = _AGENT_WEIGHTS.get(r.get("agent", ""), 1.0)
+        w      = base_w * (conf ** 2)
+        score  = _SIGNAL_SCORE.get(r.get("signal", "HOLD"), 0.0)
+        score_sum += score * w
+        total_w   += w
+    return score_sum / total_w if total_w else 0.0
+
+
+def _extract_key_points(text: str) -> List[str]:
+    points = []
+    for line in text.split("\n"):
+        line = line.strip()
+        if line.startswith(("1.", "2.", "3.", "4.", "•", "-", "·")) and len(line) > 8:
+            points.append(line.lstrip("1234567890.-•· "))
+    return points[:4]
+
+
+def _safe_float(value: Any) -> float | None:
+    try:
+        if value in (None, ""):
+            return None
+        return float(value)
+    except Exception:
+        return None
+
+
+def _fmt_price(value: Any, currency: str = "USD") -> str:
+    number = _safe_float(value)
+    return f"{currency} {number:.2f}" if number is not None else "N/A"
+
+
+def _first_level(value: Any) -> float | None:
+    if value in (None, "", [], {}):
+        return None
+    if isinstance(value, (list, tuple)):
+        for item in value:
+            level = _first_level(item)
+            if level is not None:
+                return level
+        return None
+    if isinstance(value, dict):
+        for key in ("price", "level", "value"):
+            level = _safe_float(value.get(key))
+            if level is not None:
+                return level
+        return None
+    text = str(value).replace("USD", "").replace("$", "").split(",")[0].strip()
+    return _safe_float(text)
+
+
+def _risk_stop(snapshot: Dict[str, Any], currency: str = "USD") -> str:
+    support = _first_level(snapshot.get("support") or snapshot.get("supports"))
+    if support is not None:
+        return f"below support {_fmt_price(support, currency)}"
+
+    ma60 = _safe_float(snapshot.get("ma60"))
+    price = _safe_float(snapshot.get("price"))
+    if ma60 is None:
+        return "N/A (technical stop missing)"
+    if price is not None and price < ma60:
+        return f"N/A (already below MA60; recovery level {_fmt_price(ma60, currency)})"
+    return f"below MA60 {_fmt_price(ma60, currency)}"
+
+
+def _format_market_block(data: Dict[str, Any]) -> str:
+    snapshot = data.get("market_snapshot", {}) or {}
+    quote = data.get("quote", {}) or {}
+    fundamentals = data.get("fundamentals", {}) or {}
+    technical = data.get("technical", {}) or {}
+    quality = data.get("data_quality", {}) or {}
+    return "\n".join([
+        f"data_status={quality.get('status') or snapshot.get('status') or 'unknown'}",
+        f"providers={', '.join(snapshot.get('provider_chain') or quality.get('providers') or []) or 'unknown'}",
+        f"missing={', '.join(snapshot.get('missing_fields') or quality.get('missing_fields') or []) or 'none'}",
+        f"price={snapshot.get('price') or quote.get('price')}",
+        f"market_cap={snapshot.get('market_cap') or quote.get('market_cap') or fundamentals.get('market_cap')}",
+        f"pe={snapshot.get('pe_ratio') or fundamentals.get('pe_ratio') or fundamentals.get('pe_ttm')}",
+        f"analyst_target={snapshot.get('analyst_target') or fundamentals.get('analyst_target')}",
+        f"rsi={snapshot.get('rsi') or technical.get('rsi')}",
+        f"macd_hist={snapshot.get('macd_hist') or technical.get('macd_hist')}",
+        f"ma20={snapshot.get('ma20') or technical.get('ma20')}",
+        f"ma60={snapshot.get('ma60') or technical.get('ma60')}",
+    ])
+
+
+def _template_synthesis(symbol: str, results: List[Dict], data: Dict[str, Any] | None = None) -> str:
+    data = data or {}
+    avg_s  = _calc_weighted_signal_score(results)
+    final  = str(data.get("consensus_signal") or ("BUY" if avg_s > 0.4 else ("SELL" if avg_s < -0.4 else "HOLD"))).upper()
+    conf   = float(data.get("consensus_confidence") or _calc_weighted_confidence(results))
+    snapshot = data.get("market_snapshot", {}) or {}
+    currency = snapshot.get("currency") or "USD"
+    price = _fmt_price(snapshot.get("price"), currency)
+    target = _fmt_price(snapshot.get("analyst_target"), currency) if _safe_float(snapshot.get("analyst_target")) else "N/A (analyst target missing)"
+    stop = _risk_stop(snapshot, currency)
+    providers = ", ".join(snapshot.get("provider_chain") or []) or "unknown"
+    missing = ", ".join(snapshot.get("missing_fields") or []) or "none"
+
+    agent_lines = "\n".join(
+        f"  • {r['agent'].upper()} ({r.get('confidence', 0.5):.0%}): "
+        f"{r.get('signal','?')} — " + "; ".join(r.get("key_points", [])[:1])
+        for r in results if not r.get("error")
+    )
+    return (
+        f"{symbol} 综合分析（真实数据加权汇总）\n"
+        f"当前价: {price}  数据源: {providers}  缺失: {missing}\n"
+        f"{agent_lines}\n\n"
+        f"加权信号得分: {avg_s:+.2f}  综合置信度: {conf:.0%}\n"
+        f"FINAL: {final} | Target: {target} | Stop: {stop}"
+    )