fund-cli 2.0.0__py3-none-any.whl

fund_cli/core/analyzer.py

@@ -0,0 +1,46 @@
+"""
+分析引擎基类
+
+定义分析引擎的标准接口。
+"""
+
+from abc import ABC, abstractmethod
+from typing import Any
+
+import pandas as pd
+
+
+class Analyzer(ABC):
+    """
+    分析引擎基类
+
+    所有分析引擎必须继承此类。
+    """
+
+    @abstractmethod
+    def analyze(
+        self,
+        data: pd.DataFrame,
+        **kwargs,
+    ) -> dict[str, Any]:
+        """
+        执行分析
+
+        Args:
+            data: 输入数据
+            **kwargs: 额外参数
+
+        Returns:
+            分析结果字典
+        """
+        pass
+
+    @abstractmethod
+    def get_metrics(self) -> list:
+        """
+        获取可计算的指标列表
+
+        Returns:
+            指标名称列表
+        """
+        pass

fund_cli/core/data_manager.py

@@ -0,0 +1,231 @@
+"""
+数据管理器
+
+统一管理数据源，提供数据访问接口。
+"""
+
+from datetime import date
+from typing import Any
+
+import pandas as pd
+
+from fund_cli.config import get_config
+from fund_cli.data.adapters.akshare_adapter import AKShareAdapter
+from fund_cli.data.base import DataSourceAdapter, DataSourceError
+from fund_cli.data.cache import DataCache
+
+
+class DataManager:
+    """
+    数据管理器
+
+    统一管理多个数据源，提供：
+    - 自动数据源选择
+    - 数据缓存
+    - 统一的数据访问接口
+    """
+
+    def __init__(
+        self,
+        cache: DataCache | None = None,
+        primary_source: str = "akshare",
+    ):
+        """
+        初始化数据管理器
+
+        Args:
+            cache: 缓存管理器
+            primary_source: 主数据源名称
+        """
+        self.config = get_config()
+        self._cache = cache or DataCache(
+            cache_dir=self.config.data.cache_dir,
+            default_ttl=self.config.data.cache_ttl,
+        )
+        self._primary_source = primary_source
+        self._adapters: dict[str, DataSourceAdapter] = {}
+
+        # 初始化数据源
+        self._init_adapters()
+
+    def _init_adapters(self) -> None:
+        """初始化数据源适配器"""
+        # AKShare（默认数据源）
+        if self.config.data.akshare_enabled:
+            self._adapters["akshare"] = AKShareAdapter(cache=self._cache)
+
+    def get_adapter(self, source: str | None = None) -> DataSourceAdapter:
+        """
+        获取数据源适配器
+
+        Args:
+            source: 数据源名称，默认使用主数据源
+
+        Returns:
+            数据源适配器实例
+
+        Raises:
+            DataSourceError: 数据源不可用
+        """
+        source_name = source or self._primary_source
+
+        if source_name not in self._adapters:
+            raise DataSourceError(f"数据源 {source_name} 未配置或不可用")
+
+        adapter = self._adapters[source_name]
+
+        if not adapter.is_available():
+            raise DataSourceError(f"数据源 {source_name} 不可用")
+
+        return adapter
+
+    # ========== 基金数据接口 ==========
+
+    def get_fund_info(self, fund_code: str) -> dict[str, Any]:
+        """
+        获取基金基础信息
+
+        Args:
+            fund_code: 基金代码
+
+        Returns:
+            基金信息字典
+        """
+        return self.get_adapter().get_fund_info(fund_code)
+
+    def get_fund_nav(
+        self,
+        fund_code: str,
+        start_date: date | None = None,
+        end_date: date | None = None,
+    ) -> pd.DataFrame:
+        """
+        获取基金净值数据
+
+        Args:
+            fund_code: 基金代码
+            start_date: 开始日期
+            end_date: 结束日期
+
+        Returns:
+            净值数据 DataFrame
+        """
+        return self.get_adapter().get_fund_nav(fund_code, start_date, end_date)
+
+    def search_funds(
+        self,
+        fund_type: str | None = None,
+        company: str | None = None,
+        min_scale: float | None = None,
+        max_scale: float | None = None,
+        keyword: str | None = None,
+        limit: int = 100,
+    ) -> pd.DataFrame:
+        """
+        搜索基金
+
+        Args:
+            fund_type: 基金类型
+            company: 基金公司
+            min_scale: 最小规模
+            max_scale: 最大规模
+            keyword: 关键词
+            limit: 返回数量限制
+
+        Returns:
+            基金列表 DataFrame
+        """
+        return self.get_adapter().search_funds(
+            fund_type=fund_type,
+            company=company,
+            min_scale=min_scale,
+            max_scale=max_scale,
+            keyword=keyword,
+            limit=limit,
+        )
+
+    def get_fund_list(self, fund_type: str | None = None) -> pd.DataFrame:
+        """
+        获取基金列表
+
+        Args:
+            fund_type: 基金类型筛选
+
+        Returns:
+            基金列表 DataFrame
+        """
+        return self.get_adapter().get_fund_list(fund_type)
+
+    def get_benchmark_nav(
+        self,
+        benchmark_code: str,
+        start_date: date | None = None,
+        end_date: date | None = None,
+    ) -> pd.DataFrame:
+        """
+        获取基准指数数据
+
+        Args:
+            benchmark_code: 基准指数代码
+            start_date: 开始日期
+            end_date: 结束日期
+
+        Returns:
+            基准数据 DataFrame
+        """
+        return self.get_adapter().get_benchmark_nav(benchmark_code, start_date, end_date)
+
+    def get_fund_holdings(
+        self,
+        fund_code: str,
+        report_date: date | None = None,
+    ) -> pd.DataFrame:
+        """获取基金持仓数据"""
+        return self.get_adapter().get_fund_holdings(fund_code, report_date)
+
+    def get_fund_manager(self, fund_code: str) -> dict[str, Any]:
+        """获取基金经理信息"""
+        return self.get_adapter().get_fund_manager(fund_code)
+
+    def get_fund_fee(self, fund_code: str) -> dict[str, Any]:
+        """获取基金费率信息"""
+        return self.get_adapter().get_fund_fee(fund_code)
+
+    def get_fund_rating(self, fund_code: str) -> int | None:
+        """获取基金评级"""
+        return self.get_adapter().get_fund_rating(fund_code)
+
+    def batch_get_fund_nav(
+        self,
+        fund_codes: list[str],
+        start_date: date | None = None,
+        end_date: date | None = None,
+    ) -> dict[str, pd.DataFrame]:
+        """批量获取基金净值"""
+        return self.get_adapter().batch_get_fund_nav(fund_codes, start_date, end_date)
+
+    # ========== 缓存管理 ==========
+
+    def clear_cache(self) -> None:
+        """清空缓存"""
+        self._cache.clear()
+
+    def get_cache_stats(self) -> dict:
+        """获取缓存统计"""
+        return self._cache.get_stats()
+
+    def __repr__(self) -> str:
+        sources = list(self._adapters.keys())
+        return f"DataManager(sources={sources}, primary={self._primary_source})"
+
+
+# 全局数据管理器实例
+_data_manager: DataManager | None = None
+
+
+def get_data_manager() -> DataManager:
+    """获取数据管理器实例（单例）"""
+    global _data_manager
+    if _data_manager is None:
+        _data_manager = DataManager()
+    return _data_manager

fund_cli/core/data_quality.py

@@ -0,0 +1,162 @@
+"""数据质量检查器"""
+
+from datetime import timedelta
+from typing import Any
+
+import pandas as pd
+
+
+class DataQualityChecker:
+    """
+    数据质量检查器
+
+    功能：
+    - 数据质量检查 (FUND-DATA-005)
+    - 增量更新 (FUND-DATA-006)
+    - 批量下载 (FUND-DATA-007)
+    """
+
+    def __init__(self, data_manager=None):
+        from fund_cli.core.data_manager import DataManager
+
+        self._dm = data_manager or DataManager()
+
+    def check(self, fund_code: str) -> dict[str, Any]:
+        """执行完整数据质量检查"""
+        try:
+            nav_df = self._dm.get_fund_nav(fund_code)
+            if nav_df.empty:
+                return {"fund_code": fund_code, "status": "error", "message": "无数据"}
+            completeness = self.check_completeness(nav_df)
+            accuracy = self.check_accuracy(nav_df)
+            timeliness = self.check_timeliness(nav_df)
+            overall = (
+                "good"
+                if completeness["score"] >= 90 and accuracy["score"] >= 90
+                else ("warning" if completeness["score"] >= 70 else "poor")
+            )
+            return {
+                "fund_code": fund_code,
+                "overall_status": overall,
+                "completeness": completeness,
+                "accuracy": accuracy,
+                "timeliness": timeliness,
+            }
+        except Exception as e:
+            return {"fund_code": fund_code, "status": "error", "message": str(e)}
+
+    def check_completeness(self, nav_data: pd.DataFrame) -> dict[str, Any]:
+        """完整性检查 (FUND-DATA-005)"""
+        total_rows = len(nav_data)
+        if total_rows == 0:
+            return {"score": 0, "total_rows": 0, "missing_values": {}, "date_gaps": 0}
+
+        missing = {}
+        for col in ["unit_nav", "daily_return"]:
+            if col in nav_data.columns:
+                missing[col] = int(nav_data[col].isna().sum())
+
+        # 检查日期连续性
+        if "nav_date" in nav_data.columns:
+            dates = pd.to_datetime(nav_data["nav_date"]).sort_values()
+            business_days = pd.bdate_range(dates.min(), dates.max())
+            expected_count = len(business_days)
+            gaps = expected_count - total_rows
+        else:
+            gaps = 0
+
+        score = max(0, 100 - (sum(missing.values()) + gaps) * 2)
+        return {
+            "score": min(100, score),
+            "total_rows": total_rows,
+            "missing_values": missing,
+            "date_gaps": max(0, gaps),
+        }
+
+    def check_accuracy(self, nav_data: pd.DataFrame) -> dict[str, Any]:
+        """准确性检查（异常值检测）"""
+        if nav_data.empty or "unit_nav" not in nav_data.columns:
+            return {"score": 100, "anomalies": []}
+
+        nav = nav_data["unit_nav"].dropna()
+        if len(nav) < 10:
+            return {"score": 100, "anomalies": []}
+
+        q1 = nav.quantile(0.25)
+        q3 = nav.quantile(0.75)
+        iqr = q3 - q1
+        lower = q1 - 3 * iqr
+        upper = q3 + 3 * iqr
+
+        anomalies = nav[(nav < lower) | (nav > upper)]
+        score = max(0, 100 - len(anomalies) * 5)
+        return {
+            "score": min(100, score),
+            "anomaly_count": len(anomalies),
+            "anomalies": anomalies.head(5).tolist(),
+        }
+
+    def check_timeliness(self, nav_data: pd.DataFrame) -> dict[str, Any]:
+        """时效性检查"""
+        if nav_data.empty or "nav_date" not in nav_data.columns:
+            return {"last_date": None, "days_since_update": None, "status": "unknown"}
+
+        last_date = pd.to_datetime(nav_data["nav_date"]).max()
+        today = pd.Timestamp.now().normalize()
+        days_since = (today - last_date).days
+
+        if days_since <= 1:
+            status = "current"
+        elif days_since <= 7:
+            status = "recent"
+        else:
+            status = "outdated"
+
+        return {
+            "last_date": str(last_date.date()),
+            "days_since_update": days_since,
+            "status": status,
+        }
+
+    def incremental_update(self, fund_code: str) -> dict[str, Any]:
+        """增量更新 (FUND-DATA-006)"""
+        try:
+            # 获取缓存中最新日期
+            cache = self._dm._cache
+            cached = cache.get(
+                f"fund_nav:{fund_code}:19900101:{pd.Timestamp.now().strftime('%Y%m%d')}"
+            )
+            if cached is not None and not cached.empty and "nav_date" in cached.columns:
+                last_date = pd.to_datetime(cached["nav_date"]).max().date()
+                start = last_date + timedelta(days=1)
+            else:
+                start = None
+
+            new_data = self._dm.get_fund_nav(fund_code, start_date=start)
+            return {
+                "fund_code": fund_code,
+                "new_records": len(new_data),
+                "start_date": str(start) if start else "all",
+                "status": "success",
+            }
+        except Exception as e:
+            return {"fund_code": fund_code, "status": "error", "message": str(e)}
+
+    def batch_download(self, fund_codes: list[str]) -> dict[str, Any]:
+        """批量下载 (FUND-DATA-007)"""
+        results = {}
+        success = 0
+        for code in fund_codes:
+            try:
+                nav = self._dm.get_fund_nav(code)
+                results[code] = {"status": "success", "records": len(nav)}
+                success += 1
+            except Exception as e:
+                results[code] = {"status": "error", "message": str(e)}
+
+        return {
+            "total": len(fund_codes),
+            "success": success,
+            "failed": len(fund_codes) - success,
+            "details": results,
+        }

fund_cli/core/monitor.py

@@ -0,0 +1,230 @@
+"""
+基金监控管理器
+
+提供基金池管理和净值监控功能。
+"""
+
+import json
+from datetime import datetime
+from pathlib import Path
+
+
+class FundMonitor:
+    """
+    基金监控管理器
+
+    功能：
+    - 基金池管理（增删查） (FUND-MONITOR-001)
+    - 净值监控和预警 (FUND-MONITOR-002)
+    - 数据持久化（JSON文件）
+    """
+
+    def __init__(self, config_dir: str = "~/.fund_cli"):
+        """
+        初始化监控管理器
+
+        Args:
+            config_dir: 配置目录
+        """
+        self._config_dir = Path(config_dir).expanduser()
+        self._config_dir.mkdir(parents=True, exist_ok=True)
+        self._watchlist_path = self._config_dir / "watchlist.json"
+        self._rules_path = self._config_dir / "monitor_rules.json"
+        self._pools: dict[str, list[dict]] = {}
+        self._rules: list[dict] = []
+        self._load()
+
+    def _load(self) -> None:
+        """从文件加载数据"""
+        if self._watchlist_path.exists():
+            try:
+                data = json.loads(self._watchlist_path.read_text(encoding="utf-8"))
+                self._pools = data.get("pools", {})
+            except (json.JSONDecodeError, KeyError):
+                self._pools = {}
+        else:
+            self._pools = {}
+
+        if self._rules_path.exists():
+            try:
+                self._rules = json.loads(self._rules_path.read_text(encoding="utf-8"))
+            except json.JSONDecodeError:
+                self._rules = []
+        else:
+            self._rules = []
+
+    def _save(self) -> None:
+        """保存数据到文件"""
+        self._watchlist_path.write_text(
+            json.dumps({"pools": self._pools}, ensure_ascii=False, indent=2),
+            encoding="utf-8",
+        )
+        self._rules_path.write_text(
+            json.dumps(self._rules, ensure_ascii=False, indent=2),
+            encoding="utf-8",
+        )
+
+    # ========== 基金池管理 (FUND-MONITOR-001) ==========
+
+    def add_to_pool(self, fund_code: str, group: str = "default") -> None:
+        """
+        添加基金到监控池
+
+        Args:
+            fund_code: 基金代码
+            group: 分组名称
+        """
+        if group not in self._pools:
+            self._pools[group] = []
+
+        existing = [f["code"] for f in self._pools[group]]
+        if fund_code not in existing:
+            self._pools[group].append(
+                {
+                    "code": fund_code,
+                    "added_at": datetime.now().isoformat(),
+                }
+            )
+            self._save()
+
+    def remove_from_pool(self, fund_code: str, group: str | None = None) -> bool:
+        """
+        从监控池移除基金
+
+        Args:
+            fund_code: 基金代码
+            group: 分组名称，None表示从所有分组移除
+
+        Returns:
+            是否移除成功
+        """
+        removed = False
+        if group:
+            if group in self._pools:
+                before = len(self._pools[group])
+                self._pools[group] = [f for f in self._pools[group] if f["code"] != fund_code]
+                removed = len(self._pools[group]) < before
+        else:
+            for g in self._pools:
+                before = len(self._pools[g])
+                self._pools[g] = [f for f in self._pools[g] if f["code"] != fund_code]
+                if len(self._pools[g]) < before:
+                    removed = True
+
+        if removed:
+            self._save()
+        return removed
+
+    def list_pool(self, group: str | None = None) -> list[dict]:
+        """
+        列出监控池中的基金
+
+        Args:
+            group: 分组名称，None表示列出所有
+
+        Returns:
+            基金列表
+        """
+        if group:
+            return self._pools.get(group, [])
+        result = []
+        for g, funds in self._pools.items():
+            for f in funds:
+                result.append({**f, "group": g})
+        return result
+
+    def create_pool(self, name: str) -> bool:
+        """创建新的基金池分组"""
+        if name not in self._pools:
+            self._pools[name] = []
+            self._save()
+            return True
+        return False
+
+    def delete_pool(self, name: str) -> bool:
+        """删除基金池分组"""
+        if name in self._pools and name != "default":
+            del self._pools[name]
+            self._save()
+            return True
+        return False
+
+    # ========== 净值监控 (FUND-MONITOR-002) ==========
+
+    def add_rule(
+        self, fund_code: str, rule_type: str = "nav_change", threshold: float = -2.0
+    ) -> None:
+        """添加监控规则"""
+        self._rules.append(
+            {
+                "fund_code": fund_code,
+                "rule_type": rule_type,
+                "threshold": threshold,
+                "enabled": True,
+                "created_at": datetime.now().isoformat(),
+            }
+        )
+        self._save()
+
+    def get_rules(self, fund_code: str | None = None) -> list[dict]:
+        """获取监控规则"""
+        if fund_code:
+            return [
+                r for r in self._rules if r["fund_code"] == fund_code and r.get("enabled", True)
+            ]
+        return [r for r in self._rules if r.get("enabled", True)]
+
+    def check_nav_changes(self, fund_codes: list[str], threshold: float = -2.0) -> list[dict]:
+        """
+        检查净值变动
+
+        Args:
+            fund_codes: 基金代码列表
+            threshold: 预警阈值（默认-2%）
+
+        Returns:
+            触发预警的基金列表
+        """
+        alerts = []
+        try:
+            from fund_cli.core.data_manager import DataManager
+
+            dm = DataManager()
+            for code in fund_codes:
+                try:
+                    nav_df = dm.get_fund_nav(code)
+                    if nav_df.empty or "daily_return" not in nav_df.columns:
+                        continue
+                    latest = nav_df.iloc[-1]["daily_return"]
+                    if isinstance(latest, str):
+                        latest = float(latest.replace("%", ""))
+                    if latest <= threshold:
+                        alerts.append(
+                            {
+                                "fund_code": code,
+                                "daily_return": latest,
+                                "threshold": threshold,
+                                "alert_type": "nav_change",
+                            }
+                        )
+                except Exception:
+                    continue
+        except Exception:
+            pass
+        return alerts
+
+    def get_all_fund_codes(self) -> list[str]:
+        """获取所有监控基金代码"""
+        codes = set()
+        for funds in self._pools.values():
+            for f in funds:
+                codes.add(f["code"])
+        return sorted(codes)
+
+    def get_pool_names(self) -> list[str]:
+        """获取所有基金池名称"""
+        return list(self._pools.keys())
+
+    def __repr__(self) -> str:
+        total = sum(len(funds) for funds in self._pools.values())
+        return f"FundMonitor(pools={len(self._pools)}, funds={total})"