fund-cli 2.0.0__py3-none-any.whl

fund_cli/ai/providers.py

@@ -0,0 +1,286 @@
+"""
+LLM 提供商管理（V2.0 实现）
+
+管理多个 LLM 提供商的连接和调用，支持OpenAI、阿里云Qwen等。
+"""
+
+from __future__ import annotations
+
+import time
+from abc import ABC, abstractmethod
+from typing import Any
+
+import requests
+
+from fund_cli.config import AIConfig
+
+
+class LLMProvider(ABC):
+    """LLM 提供商抽象基类"""
+
+    def __init__(self, config: AIConfig):
+        self.config = config
+
+    @abstractmethod
+    def generate(self, prompt: str, **kwargs: Any) -> str:
+        """生成文本
+
+        Args:
+            prompt: 输入提示词
+            **kwargs: 额外参数
+
+        Returns:
+            生成的文本
+        """
+        pass
+
+    @abstractmethod
+    def is_available(self) -> bool:
+        """检查提供商是否可用
+
+        Returns:
+            是否可用
+        """
+        pass
+
+    @abstractmethod
+    def validate_config(self) -> bool:
+        """验证配置是否有效
+
+        Returns:
+            配置是否有效
+        """
+        pass
+
+
+class OpenAIProvider(LLMProvider):
+    """OpenAI 提供商"""
+
+    def __init__(self, config: AIConfig):
+        super().__init__(config)
+        self.api_key = config.api_key
+        self.model = config.model or "gpt-4"
+        self.base_url = config.api_base or "https://api.openai.com/v1"
+
+    def generate(self, prompt: str, **kwargs: Any) -> str:
+        """使用 OpenAI API 生成文本"""
+        if not self.api_key:
+            raise ValueError("OpenAI API key not configured")
+
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+        }
+
+        payload = {
+            "model": kwargs.get("model", self.model),
+            "messages": [{"role": "user", "content": prompt}],
+            "temperature": kwargs.get("temperature", self.config.temperature),
+            "max_tokens": kwargs.get("max_tokens", self.config.max_tokens),
+        }
+
+        response = self._call_with_retry(f"{self.base_url}/chat/completions", headers, payload)
+
+        if response and "choices" in response:
+            return response["choices"][0]["message"]["content"]
+        raise RuntimeError("Invalid response from OpenAI API")
+
+    def is_available(self) -> bool:
+        """检查OpenAI API是否可用"""
+        if not self.api_key:
+            return False
+        try:
+            headers = {"Authorization": f"Bearer {self.api_key}"}
+            response = requests.get(
+                f"{self.base_url}/models",
+                headers=headers,
+                timeout=self.config.timeout,
+            )
+            return response.status_code == 200
+        except Exception:
+            return False
+
+    def validate_config(self) -> bool:
+        """验证配置"""
+        return bool(self.api_key and self.model)
+
+    def _call_with_retry(self, url: str, headers: dict, payload: dict) -> dict | None:
+        """带重试的API调用"""
+        last_error = None
+        for attempt in range(self.config.retry_count):
+            try:
+                response = requests.post(
+                    url,
+                    headers=headers,
+                    json=payload,
+                    timeout=self.config.timeout,
+                )
+                response.raise_for_status()
+                return response.json()
+            except requests.RequestException as e:
+                last_error = e
+                if attempt < self.config.retry_count - 1:
+                    time.sleep(2**attempt)  # 指数退避
+        raise RuntimeError(
+            f"API call failed after {self.config.retry_count} attempts: {last_error}"
+        )
+
+
+class QwenProvider(LLMProvider):
+    """阿里云Qwen 提供商"""
+
+    def __init__(self, config: AIConfig):
+        super().__init__(config)
+        self.api_key = config.qwen_api_key or config.api_key
+        self.model = config.qwen_model or "qwen-max"
+        self.base_url = config.qwen_base_url or "https://dashscope.aliyuncs.com/api/v1"
+
+    def generate(self, prompt: str, **kwargs: Any) -> str:
+        """使用 Qwen API 生成文本"""
+        if not self.api_key:
+            raise ValueError("Qwen API key not configured")
+
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+        }
+
+        payload = {
+            "model": kwargs.get("model", self.model),
+            "input": {"messages": [{"role": "user", "content": prompt}]},
+            "parameters": {
+                "temperature": kwargs.get("temperature", self.config.temperature),
+                "max_tokens": kwargs.get("max_tokens", self.config.max_tokens),
+                "result_format": "message",
+            },
+        }
+
+        response = self._call_with_retry(
+            f"{self.base_url}/services/aigc/text-generation/generation",
+            headers,
+            payload,
+        )
+
+        if response and "output" in response:
+            return response["output"]["choices"][0]["message"]["content"]
+        raise RuntimeError("Invalid response from Qwen API")
+
+    def is_available(self) -> bool:
+        """检查Qwen API是否可用"""
+        if not self.api_key:
+            return False
+        try:
+            headers = {"Authorization": f"Bearer {self.api_key}"}
+            # 使用简单的模型列表接口测试
+            response = requests.get(
+                f"{self.base_url}/models",
+                headers=headers,
+                timeout=self.config.timeout,
+            )
+            return response.status_code == 200
+        except Exception:
+            return False
+
+    def validate_config(self) -> bool:
+        """验证配置"""
+        return bool(self.api_key and self.model)
+
+    def _call_with_retry(self, url: str, headers: dict, payload: dict) -> dict | None:
+        """带重试的API调用"""
+        last_error = None
+        for attempt in range(self.config.retry_count):
+            try:
+                response = requests.post(
+                    url,
+                    headers=headers,
+                    json=payload,
+                    timeout=self.config.timeout,
+                )
+                response.raise_for_status()
+                return response.json()
+            except requests.RequestException as e:
+                last_error = e
+                if attempt < self.config.retry_count - 1:
+                    time.sleep(2**attempt)  # 指数退避
+        raise RuntimeError(
+            f"API call failed after {self.config.retry_count} attempts: {last_error}"
+        )
+
+
+class LiteLLMProvider(LLMProvider):
+    """LiteLLM 统一封装提供商"""
+
+    def __init__(self, config: AIConfig):
+        super().__init__(config)
+        self.api_key = config.api_key
+        self.model = config.model or "gpt-4"
+
+    def generate(self, prompt: str, **kwargs: Any) -> str:
+        """使用 LiteLLM 生成文本"""
+        try:
+            import litellm
+
+            litellm.api_key = self.api_key
+
+            response = litellm.completion(
+                model=self.model,
+                messages=[{"role": "user", "content": prompt}],
+                temperature=kwargs.get("temperature", self.config.temperature),
+                max_tokens=kwargs.get("max_tokens", self.config.max_tokens),
+            )
+            return response.choices[0].message.content
+        except ImportError as err:
+            raise RuntimeError("litellm not installed. Install with: pip install litellm") from err
+        except Exception as e:
+            raise RuntimeError(f"LiteLLM API error: {e}") from e
+
+    def is_available(self) -> bool:
+        """检查LiteLLM是否可用"""
+        try:
+            import importlib.util
+
+            spec = importlib.util.find_spec("litellm")
+            if spec is None:
+                return False
+            return bool(self.api_key)
+        except ImportError:
+            return False
+
+    def validate_config(self) -> bool:
+        """验证配置"""
+        return bool(self.api_key and self.model)
+
+
+def get_provider(config: AIConfig | None = None) -> LLMProvider:
+    """
+    获取 LLM 提供商实例
+
+    Args:
+        config: AI配置，如果为None则使用默认配置
+
+    Returns:
+        LLM 提供商实例
+
+    Raises:
+        ValueError: 如果提供商类型不支持
+    """
+    if config is None:
+        from fund_cli.config import get_config
+
+        config = get_config().ai
+
+    providers = {
+        "openai": OpenAIProvider,
+        "qwen": QwenProvider,
+        "litellm": LiteLLMProvider,
+    }
+
+    provider_name = config.provider.lower()
+    provider_class = providers.get(provider_name)
+
+    if provider_class is None:
+        raise ValueError(
+            f"不支持的提供商: {provider_name}. " f"支持的提供商: {', '.join(providers.keys())}"
+        )
+
+    return provider_class(config)

fund_cli/analysis/__init__.py

@@ -0,0 +1,17 @@
+"""分析模块 - 业绩分析、风险分析、归因分析、组合分析、经理分析、持仓分析"""
+
+from fund_cli.analysis.attribution import AttributionAnalyzer
+from fund_cli.analysis.holding import HoldingAnalyzer
+from fund_cli.analysis.manager import ManagerAnalyzer
+from fund_cli.analysis.performance import PerformanceAnalyzer
+from fund_cli.analysis.portfolio import PortfolioAnalyzer
+from fund_cli.analysis.risk import RiskAnalyzer
+
+__all__ = [
+    "PerformanceAnalyzer",
+    "RiskAnalyzer",
+    "AttributionAnalyzer",
+    "PortfolioAnalyzer",
+    "ManagerAnalyzer",
+    "HoldingAnalyzer",
+]

fund_cli/analysis/attribution.py

@@ -0,0 +1,161 @@
+"""
+归因分析引擎
+
+实现 Brinson 归因分析等归因分析功能。
+"""
+
+from typing import Any
+
+import numpy as np
+import pandas as pd
+
+from fund_cli.core.analyzer import Analyzer
+
+
+class AttributionAnalyzer(Analyzer):
+    """
+    归因分析引擎
+
+    支持：
+    - Brinson 归因分析（配置效应、选择效应、交互效应）
+    - 收益率分解
+    """
+
+    def analyze(
+        self,
+        data: pd.DataFrame,
+        benchmark_weights: dict[str, float] | None = None,
+        portfolio_weights: dict[str, float] | None = None,
+        **kwargs,
+    ) -> dict[str, Any]:
+        """
+        执行归因分析
+
+        Args:
+            data: 包含各资产收益率的 DataFrame
+            benchmark_weights: 基准组合权重 {资产名: 权重}
+            portfolio_weights: 投资组合权重 {资产名: 权重}
+            **kwargs: 额外参数
+
+        Returns:
+            归因分析结果字典
+        """
+        if benchmark_weights is None or portfolio_weights is None:
+            return self._simple_decomposition(data)
+
+        return self._brinson_attribution(data, benchmark_weights, portfolio_weights)
+
+    def _simple_decomposition(self, returns: pd.DataFrame) -> dict[str, Any]:
+        """
+        简单收益率分解
+
+        Args:
+            returns: 收益率 DataFrame
+
+        Returns:
+            分解结果
+        """
+        if isinstance(returns, pd.Series):
+            returns = returns.to_frame("fund")
+
+        result = {}
+        for col in returns.columns:
+            col_data = returns[col].dropna()
+            if len(col_data) == 0:
+                continue
+
+            cumulative = (1 + col_data).prod() - 1
+            annualized = (1 + cumulative) ** (252 / len(col_data)) - 1
+
+            result[col] = {
+                "total_return": float(cumulative * 100),
+                "annualized_return": float(annualized * 100),
+                "volatility": float(col_data.std() * np.sqrt(252) * 100),
+                "sharpe": float(
+                    col_data.mean() / col_data.std() * np.sqrt(252) if col_data.std() > 0 else 0
+                ),
+            }
+
+        return result
+
+    def _brinson_attribution(
+        self,
+        returns: pd.DataFrame,
+        benchmark_weights: dict[str, float],
+        portfolio_weights: dict[str, float],
+    ) -> dict[str, Any]:
+        """
+        Brinson 归因分析
+
+        将组合收益与基准收益的差异分解为：
+        - 配置效应（Allocation Effect）
+        - 选择效应（Selection Effect）
+        - 交互效应（Interaction Effect）
+
+        Args:
+            returns: 各资产收益率 DataFrame
+            benchmark_weights: 基准权重
+            portfolio_weights: 组合权重
+
+        Returns:
+            Brinson 归因结果
+        """
+        common_assets = (
+            set(benchmark_weights.keys()) & set(portfolio_weights.keys()) & set(returns.columns)
+        )
+
+        if not common_assets:
+            return {
+                "allocation_effect": 0.0,
+                "selection_effect": 0.0,
+                "interaction_effect": 0.0,
+                "total_active_return": 0.0,
+            }
+
+        # 计算各资产平均收益率
+        asset_returns = {}
+        for asset in common_assets:
+            if asset in returns.columns:
+                asset_returns[asset] = returns[asset].mean()
+
+        # Brinson 归因分解
+        allocation_effect = 0.0
+        selection_effect = 0.0
+        interaction_effect = 0.0
+
+        benchmark_total_return = 0.0
+        portfolio_total_return = 0.0
+
+        for asset in common_assets:
+            wp = portfolio_weights.get(asset, 0)
+            wb = benchmark_weights.get(asset, 0)
+            rp = asset_returns.get(asset, 0)
+            rb = rp  # 简化：假设基准收益率等于资产收益率
+
+            allocation_effect += (wp - wb) * rb
+            selection_effect += wb * (rp - rb)
+            interaction_effect += (wp - wb) * (rp - rb)
+
+            portfolio_total_return += wp * rp
+            benchmark_total_return += wb * rb
+
+        total_active = portfolio_total_return - benchmark_total_return
+
+        return {
+            "allocation_effect": float(allocation_effect * 252 * 100),
+            "selection_effect": float(selection_effect * 252 * 100),
+            "interaction_effect": float(interaction_effect * 252 * 100),
+            "total_active_return": float(total_active * 252 * 100),
+            "portfolio_return": float(portfolio_total_return * 252 * 100),
+            "benchmark_return": float(benchmark_total_return * 252 * 100),
+            "asset_count": len(common_assets),
+        }
+
+    def get_metrics(self) -> list[str]:
+        """获取可计算的指标列表"""
+        return [
+            "allocation_effect",
+            "selection_effect",
+            "interaction_effect",
+            "total_active_return",
+        ]

fund_cli/analysis/backtest.py

@@ -0,0 +1,75 @@
+"""组合回测引擎"""
+
+from typing import Any
+
+import numpy as np
+import pandas as pd
+
+from fund_cli.core.analyzer import Analyzer
+
+
+class BacktestAnalyzer(Analyzer):
+    """组合回测引擎 - PORTFOLIO-OPT-007"""
+
+    def analyze(self, data: pd.DataFrame, **kwargs: Any) -> dict[str, Any]:
+        weights = kwargs.get("weights", {})
+        return self.run_backtest(data, weights)
+
+    def run_backtest(
+        self,
+        returns: pd.DataFrame,
+        weights: dict[str, float] | None = None,
+        rebalance_freq: str = "monthly",
+    ) -> dict[str, Any]:
+        """
+        运行组合回测
+
+        Args:
+            returns: 多基金收益率 DataFrame
+            weights: 基金权重字典，None表示等权
+            rebalance_freq: 再平衡频率 (daily/monthly/quarterly/yearly/never)
+
+        Returns:
+            回测结果字典
+        """
+        if weights is None:
+            n = returns.shape[1]
+            weights = dict.fromkeys(returns.columns, 1.0 / n)
+
+        w = pd.Series(weights)
+        daily_returns = (returns * w).sum(axis=1)
+
+        # 计算净值曲线
+        nav = (1 + daily_returns).cumprod()
+
+        # 计算指标
+        total_days = len(daily_returns)
+        total_return = (nav.iloc[-1] / nav.iloc[0] - 1) * 100 if len(nav) > 1 else 0
+        annual_return = (1 + total_return / 100) ** (252 / total_days) - 1 if total_days > 0 else 0
+        annual_vol = daily_returns.std() * np.sqrt(252) * 100
+        sharpe = (annual_return - 0.03) / (annual_vol / 100) if annual_vol > 0 else 0
+
+        # 最大回撤
+        peak = nav.cummax()
+        drawdown = (nav - peak) / peak
+        max_drawdown = drawdown.min() * 100
+
+        # 胜率
+        win_rate = (
+            (daily_returns > 0).sum() / len(daily_returns) * 100 if len(daily_returns) > 0 else 0
+        )
+
+        return {
+            "total_return": round(total_return, 4),
+            "annual_return": round(annual_return * 100, 4),
+            "annual_volatility": round(annual_vol, 4),
+            "sharpe_ratio": round(sharpe, 4),
+            "max_drawdown": round(max_drawdown, 4),
+            "win_rate": round(win_rate, 2),
+            "trading_days": total_days,
+            "rebalance_freq": rebalance_freq,
+            "nav_curve": nav.tolist()[-10:],  # 最后10个净值点
+        }
+
+    def get_metrics(self) -> list[str]:
+        return ["total_return", "annual_return", "sharpe_ratio", "max_drawdown", "win_rate"]