aria-code 4.1.3__py3-none-any.whl

agents/registry.py

@@ -0,0 +1,144 @@
+"""
+agents/registry.py — Agent 注册与自动发现
+==========================================
+1. 内置 agent 预注册（technical / fundamental / macro / risk）
+2. 扫描 ./aria_agents/ → 自动注册用户自定义 agent
+3. 提供 get() / list() / register() 接口
+
+自定义 Agent 放置规则:
+    项目根/aria_agents/my_agent.py
+    类需继承 BaseAgent，且声明 name 属性
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import inspect
+import logging
+import sys
+from pathlib import Path
+from typing import Dict, List, Optional, Type
+
+from .base import BaseAgent
+from .financial.technical import TechnicalAgent
+
+logger = logging.getLogger(__name__)
+
+# ── 内置 agent 预注册 ─────────────────────────────────────────────────────────
+_BUILTIN: Dict[str, Type[BaseAgent]] = {
+    "technical": TechnicalAgent,
+}
+
+# 尝试加载其他内置 agent（文件存在则注册）
+def _try_import_builtin(module_path: str, name: str) -> None:
+    try:
+        parts = module_path.split(".")
+        mod = importlib.import_module(module_path)
+        for _, cls in inspect.getmembers(mod, inspect.isclass):
+            if issubclass(cls, BaseAgent) and cls is not BaseAgent:
+                _BUILTIN[cls.name] = cls
+    except ImportError:
+        pass
+
+
+_try_import_builtin("agents.financial.macro",       "macro")
+_try_import_builtin("agents.financial.fundamental",  "fundamental")
+_try_import_builtin("agents.financial.risk",         "risk")
+_try_import_builtin("agents.financial.synthesis",    "synthesis")
+_try_import_builtin("agents.financial.news",         "news")
+_try_import_builtin("agents.financial.catalyst",     "catalyst")
+_try_import_builtin("agents.financial.debate",       "debate")
+_try_import_builtin("agents.financial.earnings",     "earnings")
+_try_import_builtin("agents.financial.sector",       "sector")
+_try_import_builtin("agents.portfolio_agent",        "portfolio")
+
+# ── 经营权共创平台 Agent 包 ────────────────────────────────────────────────────
+_try_import_builtin("agents.realty.asset_diagnosis",  "asset_diagnosis")
+_try_import_builtin("agents.realty.business_match",   "business_match")
+_try_import_builtin("agents.realty.contract_rules",   "contract_rules")
+_try_import_builtin("agents.realty.revenue_share",    "revenue_share")
+_try_import_builtin("agents.realty.cashflow_verify",  "cashflow_verify")
+_try_import_builtin("agents.realty.energy_anomaly",   "energy_anomaly")
+_try_import_builtin("agents.realty.fulfillment_risk", "fulfillment_risk")
+_try_import_builtin("agents.realty.ops_optimize",     "ops_optimize")
+_try_import_builtin("agents.realty.exit_settlement",  "exit_settlement")
+
+
+class AgentRegistry:
+    """
+    Agent 注册中心（单例）。
+
+    用法:
+        registry = get_registry()
+        registry.register(MyAgent)
+        agent_cls = registry.get("my_agent")
+    """
+
+    def __init__(self):
+        self._agents: Dict[str, Type[BaseAgent]] = dict(_BUILTIN)
+        self._scanned = False
+
+    def register(self, cls: Type[BaseAgent]) -> None:
+        """手动注册一个 Agent 类"""
+        if not (isinstance(cls, type) and issubclass(cls, BaseAgent)):
+            raise TypeError(f"{cls} 不是 BaseAgent 子类")
+        self._agents[cls.name] = cls
+        logger.info(f"✓ 注册 Agent: {cls.name}")
+
+    def get(self, name: str) -> Optional[Type[BaseAgent]]:
+        """按名称获取 Agent 类"""
+        self._ensure_scanned()
+        return self._agents.get(name.lower())
+
+    def list(self) -> List[Dict]:
+        """列出所有已注册 Agent"""
+        self._ensure_scanned()
+        return [
+            {"name": name, "description": cls.description, "builtin": name in _BUILTIN}
+            for name, cls in self._agents.items()
+        ]
+
+    def _ensure_scanned(self) -> None:
+        if not self._scanned:
+            self._scan_project()
+            self._scanned = True
+
+    def _scan_project(self) -> None:
+        """扫描当前工作目录及父级的 aria_agents/ 目录"""
+        search_paths = [Path.cwd(), Path.cwd().parent]
+        for base in search_paths:
+            agents_dir = base / "aria_agents"
+            if not agents_dir.is_dir():
+                continue
+            for py_file in sorted(agents_dir.glob("*.py")):
+                if py_file.name.startswith("_"):
+                    continue
+                self._load_file(py_file)
+            break   # 找到第一个 aria_agents/ 即停止向上搜索
+
+    def _load_file(self, path: Path) -> None:
+        """加载一个 .py 文件，自动注册其中的 BaseAgent 子类"""
+        try:
+            spec   = importlib.util.spec_from_file_location(path.stem, path)
+            module = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(module)
+            for _, cls in inspect.getmembers(module, inspect.isclass):
+                if (cls.__module__ == module.__name__
+                        and issubclass(cls, BaseAgent)
+                        and cls is not BaseAgent
+                        and hasattr(cls, "name")
+                        and cls.name != "base"):
+                    self._agents[cls.name] = cls
+                    logger.info(f"✓ 自动发现 Agent: {cls.name} ({path.name})")
+        except Exception as e:
+            logger.warning(f"加载 agent 文件 {path} 失败: {e}")
+
+
+# ── 单例 ──────────────────────────────────────────────────────────────────────
+_registry: Optional[AgentRegistry] = None
+
+def get_registry() -> AgentRegistry:
+    global _registry
+    if _registry is None:
+        _registry = AgentRegistry()
+    return _registry

agents/sports/football_agent.py

@@ -0,0 +1,169 @@
+"""
+agents/sports/football_agent.py — Football Analysis Agent
+===========================================================
+LLM-powered football match analysis using Poisson prediction + form data.
+"""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class MatchPrediction:
+    home_team:    str
+    away_team:    str
+    league:       str
+    home_win:     float
+    draw:         float
+    away_win:     float
+    btts:         float
+    lambda_home:  float
+    lambda_away:  float
+    most_likely:  str
+    top_scores:   List[Dict]
+    implied_odds: Dict[str, float]
+    analysis:     str = ""
+    key_factors:  List[str] = field(default_factory=list)
+
+    @property
+    def verdict(self) -> str:
+        probs = {"home": self.home_win, "draw": self.draw, "away": self.away_win}
+        winner = max(probs, key=probs.get)
+        dominant = probs[winner] > 0.50
+        if winner == "home":
+            return f"主队{'强势' if dominant else '略有'}优势 ({self.home_win:.0%})"
+        elif winner == "away":
+            return f"客队{'强势' if dominant else '略有'}优势 ({self.away_win:.0%})"
+        else:
+            return f"势均力敌，平局概率较高 ({self.draw:.0%})"
+
+
+class FootballAgent:
+    """
+    Football analysis combining Poisson prediction + LLM interpretation.
+    Can run standalone (no LLM) or enhanced with LLM narrative.
+    """
+
+    name = "football"
+    description = "足球赛事分析与预测 — 泊松模型 + 近期战绩 + xG数据"
+
+    def __init__(self, llm_call=None):
+        self._llm = llm_call  # Optional: async fn(prompt) -> str
+
+    async def predict(
+        self,
+        home_team: str,
+        away_team: str,
+        league: str = "pl",
+        with_llm: bool = True,
+    ) -> MatchPrediction:
+        from football_data_client import predict_match, get_team_stats
+
+        raw = predict_match(home_team, away_team, league)
+        h_stats = get_team_stats(league, home_team)
+        a_stats = get_team_stats(league, away_team)
+
+        key_factors = []
+        if h_stats:
+            key_factors.append(f"{home_team} 近5场: {h_stats['form']} (场均进球 {h_stats['avg_gf']})")
+        if a_stats:
+            key_factors.append(f"{away_team} 近5场: {a_stats['form']} (场均进球 {a_stats['avg_gf']})")
+        key_factors.append(f"主场优势系数: ×1.25 (泊松模型)")
+
+        analysis = ""
+        if with_llm and self._llm:
+            prompt = _build_analysis_prompt(raw, h_stats, a_stats)
+            try:
+                analysis = await self._llm(prompt)
+            except Exception as exc:
+                logger.warning("LLM analysis failed: %s", exc)
+                analysis = _fallback_analysis(raw)
+        else:
+            analysis = _fallback_analysis(raw)
+
+        return MatchPrediction(
+            home_team=home_team,
+            away_team=away_team,
+            league=league,
+            home_win=raw["home_win"],
+            draw=raw["draw"],
+            away_win=raw["away_win"],
+            btts=raw["btts"],
+            lambda_home=raw["lambda_home"],
+            lambda_away=raw["lambda_away"],
+            most_likely=raw["most_likely_score"],
+            top_scores=raw["top_scorelines"],
+            implied_odds=raw["implied_odds"],
+            analysis=analysis,
+            key_factors=key_factors,
+        )
+
+
+def _fallback_analysis(raw: Dict) -> str:
+    hw, d, aw = raw["home_win"], raw["draw"], raw["away_win"]
+    lh, la = raw["lambda_home"], raw["lambda_away"]
+    ht, at = raw["home_team"], raw["away_team"]
+
+    lines = []
+    if hw > aw + 0.15:
+        lines.append(f"泊松模型显示 **{ht}** 主场优势明显（胜率 {hw:.0%}）")
+    elif aw > hw + 0.15:
+        lines.append(f"泊松模型显示 **{at}** 客场表现更强（胜率 {aw:.0%}）")
+    else:
+        lines.append(f"双方实力相当，平局可能性较大（{d:.0%}）")
+
+    lines.append(f"预期进球：{ht} {lh:.1f} / {at} {la:.1f}")
+    top = raw["top_scorelines"][:3]
+    score_str = " | ".join(f"{s['score']}({s['prob']}%)" for s in top)
+    lines.append(f"高概率比分：{score_str}")
+    btts = raw["btts"]
+    lines.append(f"双方均进球概率：{btts:.0%}")
+
+    return "\n".join(lines)
+
+
+def _build_analysis_prompt(raw: Dict, h_stats: Optional[Dict], a_stats: Optional[Dict]) -> str:
+    top_scores = "、".join(
+        f"{s['score']}({s['prob']}%)"
+        for s in raw.get("top_scorelines", [])[:5]
+    )
+    return f"""你是一位专业足球分析师。根据以下泊松预测模型数据，用中文分析这场比赛：
+
+【比赛】{raw['home_team']} vs {raw['away_team']}
+
+【预测概率】
+主队胜: {raw['home_win']:.1%}  平局: {raw['draw']:.1%}  客队胜: {raw['away_win']:.1%}
+预期进球: 主队 {raw['lambda_home']:.2f} / 客队 {raw['lambda_away']:.2f}
+最可能比分: {raw['most_likely_score']}
+候选比分（按模型概率降序）: {top_scores}
+双方均进球: {raw['btts']:.1%}
+
+【近期战绩】
+{_format_stats(raw['home_team'], h_stats)}
+{_format_stats(raw['away_team'], a_stats)}
+
+请提供:
+1. 比赛走势分析（3-4句）
+2. 关键影响因素（2-3条）
+3. 预测建议（1句话结论）
+
+规则:
+- 必须按“候选比分”概率顺序讨论比分，不要把低概率比分排到第一。
+- 不要编造射正率、历史交锋、最近5场客场等输入数据之外的具体数字。
+- 如果给出多个准确比分，直接引用候选比分及概率。
+
+简洁专业，不超过200字。"""
+
+
+def _format_stats(team: str, stats: Optional[Dict]) -> str:
+    if not stats:
+        return f"{team}: 数据不足"
+    return (
+        f"{team}: 近{stats['last_n']}场 {stats['w']}胜{stats['d']}平{stats['l']}负, "
+        f"进{stats['gf']}球失{stats['ga']}球, 近5场战绩: {stats['form']}"
+    )

agents/team.py

@@ -0,0 +1,289 @@
+"""
+agents/team.py — 多 Agent 并行执行与结果汇总
+=============================================
+/team AAPL                          → 运行默认4个内置 agent
+/team AAPL --agents macro,technical → 只运行指定 agent
+/team AAPL --agents macro,my_agent  → 内置 + 自定义混合
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import time
+from dataclasses import dataclass, field
+from typing import Any, Callable, Dict, List, Optional
+
+from .base import BaseAgent, AgentResult
+from .registry import get_registry
+
+logger = logging.getLogger(__name__)
+
+# 默认 team 构成
+DEFAULT_TEAM = ["macro", "fundamental", "technical", "risk"]
+
+
+@dataclass
+class TeamResult:
+    symbol:       str
+    agents_run:   List[str]
+    results:      List[AgentResult]
+    synthesis:    str = ""             # 综合结论（synthesis agent 输出）
+    final_signal: str = "HOLD"        # 多数表决
+    confidence:   float = 0.0
+    elapsed_sec:  float = 0.0
+    error:        Optional[str] = None
+
+
+class AgentTeam:
+    """
+    并行运行多个 Agent，汇总结果。
+
+    用法:
+        team   = AgentTeam(llm_provider=provider, data_router=router)
+        result = await team.run("NVDA", agents=["macro","technical","risk"])
+    """
+
+    def __init__(
+        self,
+        llm_provider=None,
+        data_router=None,
+        on_token: Optional[Callable[[str], None]] = None,
+        on_agent_done: Optional[Callable[[str, AgentResult], None]] = None,
+        on_synthesis_start: Optional[Callable[[List["AgentResult"]], None]] = None,
+        timeout_per_agent: float = 60.0,
+        lang: str = "zh",
+    ):
+        self.llm                = llm_provider
+        self.data               = data_router
+        self.on_token           = on_token
+        self.on_agent_done      = on_agent_done
+        self.on_synthesis_start = on_synthesis_start
+        self.timeout            = timeout_per_agent
+        self.lang               = lang
+
+    def _build_agent(self, name: str) -> Optional[BaseAgent]:
+        registry = get_registry()
+        cls = registry.get(name)
+        if not cls:
+            logger.warning(f"未知 Agent: {name}，跳过")
+            return None
+        return cls(
+            llm_provider=self.llm,
+            data_router=self.data,
+            on_token=self.on_token,
+            lang=self.lang,
+        )
+
+    async def _run_one(self, agent: BaseAgent, symbol: str) -> AgentResult:
+        try:
+            result = await asyncio.wait_for(
+                agent.run(symbol), timeout=self.timeout
+            )
+            if self.on_agent_done:
+                self.on_agent_done(agent.name, result)
+            return result
+        except asyncio.TimeoutError:
+            logger.warning(f"[{agent.name}] 超时 ({self.timeout}s)")
+            _timeout_result = AgentResult(
+                agent=agent.name, symbol=symbol,
+                analysis="", confidence=0.0, error="timeout",
+            )
+            # Still emit the leaf so the streaming tree shows ⎿ ⏺ <agent> 超时
+            if self.on_agent_done:
+                try:
+                    self.on_agent_done(agent.name, _timeout_result)
+                except Exception:
+                    pass
+            return _timeout_result
+
+    async def run(
+        self,
+        symbol: str,
+        agents: Optional[List[str]] = None,
+        market_context: Optional[Dict[str, Any]] = None,
+    ) -> TeamResult:
+        """并行运行所有 agent，等待全部完成后汇总。"""
+        names_to_run = agents or DEFAULT_TEAM
+        t0 = time.time()
+
+        # 过滤掉 synthesis 和 debate（各自在并行批次后单独运行）
+        regular = [n for n in names_to_run if n not in ("synthesis", "debate")]
+        agent_objects = [a for n in regular if (a := self._build_agent(n))]
+
+        if not agent_objects:
+            return TeamResult(
+                symbol=symbol, agents_run=[], results=[],
+                error="no_agents_available"
+            )
+
+        # 并行执行 — return_exceptions=True 确保单个 agent 异常不取消其余 agent
+        tasks   = [self._run_one(a, symbol) for a in agent_objects]
+        _raw    = await asyncio.gather(*tasks, return_exceptions=True)
+        results: List[AgentResult] = []
+        for _item, _agent in zip(_raw, agent_objects):
+            if isinstance(_item, BaseException):
+                logger.warning("[%s] 意外异常: %s", _agent.name, _item)
+                results.append(AgentResult(
+                    agent=_agent.name, symbol=symbol,
+                    analysis="", confidence=0.0,
+                    error=f"exception: {type(_item).__name__}: {_item}",
+                ))
+            else:
+                results.append(_item)
+
+        # DebateAgent — 显式请求 OR 信号冲突时自动触发
+        explicit_debate = "debate" in names_to_run
+        if explicit_debate or _needs_debate(results):
+            debate_agent = self._build_agent("debate")
+            if debate_agent:
+                debate_data = {"conflicting": [r.to_dict() for r in results if r.success]}
+                try:
+                    debate_result = await asyncio.wait_for(
+                        debate_agent.analyze(symbol, debate_data),
+                        timeout=self.timeout,
+                    )
+                    results.append(debate_result)
+                    logger.info("[debate] %s 信号冲突已调解", symbol)
+                except Exception as e:
+                    logger.warning("[debate] 调解失败: %s", e)
+
+        # Fire on_synthesis_start callback so callers can print the agent table
+        # before synthesis begins streaming tokens.
+        if self.on_synthesis_start:
+            try:
+                self.on_synthesis_start(list(results))
+            except Exception:
+                pass
+
+        final_signal, confidence = _vote_signal(results)
+
+        # synthesis — 把 agent 结果打包进 data，直接调 analyze() 而非 run()
+        synthesis_text = ""
+        if "synthesis" in names_to_run or len(agent_objects) >= 2:
+            synth_cls = get_registry().get("synthesis")
+            if synth_cls:
+                synth_agent = synth_cls(
+                    llm_provider=self.llm,
+                    data_router=self.data,
+                    on_token=self.on_token,
+                )
+                synth_data = {
+                    "agent_results": [r.to_dict() for r in results],
+                    "consensus_signal": final_signal,
+                    "consensus_confidence": confidence,
+                }
+                if market_context:
+                    synth_data.update(market_context)
+                try:
+                    synth_result = await asyncio.wait_for(
+                        synth_agent.analyze(symbol, synth_data),
+                        timeout=self.timeout,
+                    )
+                    synthesis_text = synth_result.analysis
+                except Exception as e:
+                    logger.warning(f"[synthesis] 失败: {e}")
+                    synthesis_text = _template_synthesis(results)
+            else:
+                synthesis_text = _template_synthesis(results)
+        else:
+            synthesis_text = _template_synthesis(results)
+
+        return TeamResult(
+            symbol       = symbol,
+            agents_run   = [a.name for a in agent_objects],
+            results      = list(results),
+            synthesis    = synthesis_text,
+            final_signal = final_signal,
+            confidence   = confidence,
+            elapsed_sec  = round(time.time() - t0, 1),
+        )
+
+
+# ── 独立函数（兼容旧 financial_agents.py 调用方式）──────────────────────────
+
+async def run_team(
+    symbol: str,
+    agents: Optional[List[str]] = None,
+    llm_provider=None,
+    data_router=None,
+    on_token: Optional[Callable] = None,
+    on_agent_done: Optional[Callable] = None,
+    on_synthesis_start: Optional[Callable] = None,
+    lang: str = "zh",
+    market_context: Optional[Dict[str, Any]] = None,
+) -> TeamResult:
+    """
+    便捷函数，替代原 financial_agents.run_team_analysis()。
+
+    旧签名兼容:
+        result = await run_team_analysis("NVDA", ollama_url, model, on_token)
+    新签名:
+        result = await run_team("NVDA", llm_provider=provider, on_token=cb)
+    """
+    team = AgentTeam(
+        llm_provider=llm_provider,
+        data_router=data_router,
+        on_token=on_token,
+        on_agent_done=on_agent_done,
+        on_synthesis_start=on_synthesis_start,
+        lang=lang,
+    )
+    return await team.run(symbol, agents=agents, market_context=market_context)
+
+
+# ── 内部工具 ──────────────────────────────────────────────────────────────────
+
+def _needs_debate(results: List[AgentResult]) -> bool:
+    """当出现真实多空分歧（至少1个BUY + 1个SELL）时返回 True。"""
+    signals = [r.signal for r in results if r.success and r.signal]
+    bullish = sum(1 for s in signals if s in ("BUY", "STRONG_BUY"))
+    bearish = sum(1 for s in signals if s in ("SELL", "STRONG_SELL"))
+    return bullish >= 1 and bearish >= 1
+
+
+def _vote_signal(results: List[AgentResult]) -> tuple:
+    """多数表决最终信号"""
+    _SCORE = {
+        "STRONG_BUY": 2, "BUY": 1, "HOLD": 0, "SELL": -1, "STRONG_SELL": -2
+    }
+    valid = [r for r in results if r.success and r.signal in _SCORE]
+    if not valid:
+        return "HOLD", 0.0
+
+    avg_score = sum(_SCORE[r.signal] * r.confidence for r in valid) / len(valid)
+    avg_conf  = sum(r.confidence for r in valid) / len(valid)
+
+    if avg_score >= 1.5:
+        return "STRONG_BUY", avg_conf
+    if avg_score >= 0.5:
+        return "BUY", avg_conf
+    if avg_score <= -1.5:
+        return "STRONG_SELL", avg_conf
+    if avg_score <= -0.5:
+        return "SELL", avg_conf
+    return "HOLD", avg_conf
+
+
+def _template_synthesis(results: List[AgentResult]) -> str:
+    """无 synthesis agent 时的模板汇总"""
+    if not results:
+        return "分析完成，无结果。"
+    lines = ["## 团队分析汇总\n"]
+    failed_count = sum(1 for r in results if not r.success)
+    if failed_count:
+        lines.append(f"> ⚠️ {failed_count}/{len(results)} 个 agent 未能完成分析"
+                     f"（超时或 LLM 不可用），以下结论仅基于成功的 agent。\n")
+    for r in results:
+        if r.success:
+            lines.append(f"**{r.agent.upper()}** ({r.signal}, 置信度 {r.confidence:.0%})")
+            for pt in (r.key_points or [])[:3]:
+                lines.append(f"  • {pt}")
+        else:
+            err_label = "超时" if r.error == "timeout" else (r.error or "分析失败")
+            lines.append(f"**{r.agent.upper()}** ⚠️ {err_label}")
+    signal, conf = _vote_signal(results)
+    lines.append(f"\n**综合结论**: {signal}（置信度 {conf:.0%}）")
+    if failed_count == len(results):
+        lines.append("\n> ⚠️ 所有 agent 均未成功，此结论仅为默认值，不具参考意义。请确认 LLM 服务正常后重试。")
+    return "\n".join(lines)