quantcli 0.1.4__tar.gz → 0.1.6__tar.gz

{quantcli-0.1.4/quantcli.egg-info → quantcli-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quantcli
-Version: 0.1.4
+Version: 0.1.6
 Summary: 面向AI的多因子量化选股策略挖掘工具，AI Agent 友好 CLI
 Author-email: QuantCLI Team <quantcli@example.com>
 Project-URL: repository, https://github.com/wumu2013/quantcli

{quantcli-0.1.4 → quantcli-0.1.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "quantcli"
-version = "0.1.4"
+version = "0.1.6"
 description = "面向AI的多因子量化选股策略挖掘工具，AI Agent 友好 CLI"
 readme = "README.md"
 requires-python = ">=3.9"

{quantcli-0.1.4 → quantcli-0.1.6}/quantcli/cli.py

@@ -183,6 +183,31 @@ def data_health(ctx):
         click.echo(f"  {k}: {v}")
 
 
+@data.command("sync-fundamentals")
+@click.option("--years", type=str, default="2022-2024", help="Year range (e.g., 2020-2024)")
+@click.pass_context
+def data_sync_fundamentals(ctx, years):
+    """同步基本面数据到 MySQL (从 akshare 批量获取)"""
+    from .datasources.mysql import MySQLDataSource
+
+    # 解析年份范围
+    try:
+        start_year, end_year = map(int, years.split("-"))
+    except ValueError:
+        click.echo(f"Invalid year format: {years}. Use format: 2020-2024")
+        return
+
+    click.echo(f"Syncing fundamentals from {start_year} to {end_year}...")
+
+    try:
+        with MySQLDataSource() as ds:
+            ds.sync_fundamentals(start_year, end_year)
+        click.echo("Sync completed successfully")
+    except Exception as e:
+        click.echo(f"Sync failed: {e}", err=True)
+        sys.exit(1)
+
+
 # =============================================================================
 # Factors 命令 - 列出内置因子
 # =============================================================================

{quantcli-0.1.4 → quantcli-0.1.6}/quantcli/datasources/baostock.py

@@ -64,8 +64,19 @@ class BaostockDataSource(DataSource):
             raise RuntimeError(f"Baostock 登录失败: {lg.error_msg}")
 
     def _to_bs_symbol(self, symbol: str) -> str:
-        """转换为 baostock 格式"""
-        symbol = symbol.replace(".SH", "").replace(".SZ", "")
+        """转换为 baostock 格式
+
+        支持格式:
+        - "600519" -> "sh.600519"
+        - "SH600519" -> "sh.600519"
+        - "sh.600519" -> "sh.600519"
+        - "SZ000001" -> "sz.000001"
+        """
+        #转 统一大写，移除前缀
+        symbol = symbol.upper()
+        symbol = symbol.replace(".SH", "").replace(".SZ", "").replace("SH", "").replace("SZ", "")
+
+        # 判断交易所
         if symbol.startswith(("6", "5", "9")):
             return f"sh.{symbol}"
         return f"sz.{symbol}"

quantcli-0.1.6/quantcli/datasources/fundamentals/__init__.py

@@ -0,0 +1,8 @@
+"""基本面数据模块
+
+提供批量获取东方财富基本面数据的接口。
+"""
+
+from .provider import FundamentalsProvider
+
+__all__ = ["FundamentalsProvider"]

quantcli-0.1.6/quantcli/datasources/fundamentals/provider.py

@@ -0,0 +1,278 @@
+"""基本面数据 Provider - 批量获取东方财富基本面数据"""
+
+from datetime import date
+from typing import Dict, List, Optional
+import pandas as pd
+
+import akshare as ak
+
+from ...utils import get_logger
+from ...utils.symbol_utils import to_mysql_from_akshare
+
+logger = get_logger(__name__)
+
+
+class FundamentalsProvider:
+    """基本面数据提供者（批量获取）
+
+    使用东方财富数据中心接口，一次获取指定日期的所有股票基本面数据。
+    支持缓存，避免重复请求。
+
+    使用示例:
+        >>> provider = FundamentalsProvider()
+        >>> df = provider.get_yjbb("20240630")
+        >>> reports = provider.get_all_reports(["20240331", "20240630"])
+    """
+
+    # 字段映射：原始字段 -> 标准字段名
+    YJBB_FIELDS = {
+        '股票代码': 'symbol',
+        '每股收益': 'eps',
+        '净利润': 'net_profits',
+        '营业总收入-营业总收入': 'revenue',
+        '营业总收入-同比增长': 'revenue_yoy',
+        '净利润-同比增长': 'netprofit_yoy',
+        '净利润-季度环比增长': 'netprofit_qoq',
+        '销售毛利率': 'grossprofitmargin',
+        '每股净资产': 'bps',  # 每股净资产
+        '净资产收益率': 'roe',
+        '每股经营现金流量': 'ocf_per_share',
+        '最新公告日期': 'announce_date',
+    }
+
+    LRB_FIELDS = {
+        '股票代码': 'symbol',
+        '净利润': 'net_profits',
+        '净利润同比': 'netprofit_yoy',
+        '营业总收入': 'revenue',
+        '营业总收入同比': 'revenue_yoy',
+    }
+
+    ZCFZ_FIELDS = {
+        '股票代码': 'symbol',
+    }
+
+    XJLL_FIELDS = {
+        '股票代码': 'symbol',
+        '经营活动产生的现金流量净额': 'ocf',
+    }
+
+    def __init__(self, use_cache: bool = True):
+        """初始化 Provider
+
+        Args:
+            use_cache: 是否缓存请求结果，默认 True
+        """
+        self._use_cache = use_cache
+        self._cache: Dict[str, pd.DataFrame] = {}
+
+    def _fetch_and_cache(self, report_type: str, date: str) -> pd.DataFrame:
+        """获取数据并缓存"""
+        cache_key = f"{report_type}_{date}"
+
+        if self._use_cache and cache_key in self._cache:
+            logger.debug(f"缓存命中: {cache_key}")
+            return self._cache[cache_key].copy()
+
+        # 根据类型调用接口
+        fetchers = {
+            'yjbb': ak.stock_yjbb_em,
+            'lrb': ak.stock_lrb_em,
+            'zcfz': ak.stock_zcfz_em,
+            'xjll': ak.stock_xjll_em,
+        }
+
+        fetcher = fetchers.get(report_type)
+        if not fetcher:
+            raise ValueError(f"未知报表类型: {report_type}")
+
+        try:
+            df = fetcher(date=date)
+            if df.empty:
+                logger.warning(f"无数据: {report_type} {date}")
+                return pd.DataFrame()
+
+            # 转换代码格式
+            df['symbol'] = df['股票代码'].apply(to_mysql_from_akshare)
+
+            # 缓存
+            if self._use_cache:
+                self._cache[cache_key] = df.copy()
+
+            return df
+        except Exception as e:
+            logger.error(f"获取 {report_type} {date} 失败: {e}")
+            return pd.DataFrame()
+
+    def get_yjbb(self, date: str) -> pd.DataFrame:
+        """获取业绩报表数据
+
+        Args:
+            date: 财报日期，如 "20240630"
+
+        Returns:
+            包含所有股票的业绩报表数据
+        """
+        df = self._fetch_and_cache('yjbb', date)
+        if df.empty:
+            return pd.DataFrame(columns=['symbol', 'eps', 'net_profits', 'revenue',
+                                        'revenue_yoy', 'netprofit_yoy', 'grossprofitmargin',
+                                        'bps', 'roe'])
+
+        # 原始列名 -> 重命名后列名（注意：symbol 已由 _fetch_and_cache 转换）
+        rename_map = {
+            '每股收益': 'eps',
+            '净利润-净利润': 'net_profits',
+            '营业总收入-营业总收入': 'revenue',
+            '营业总收入-同比增长': 'revenue_yoy',
+            '净利润-同比增长': 'netprofit_yoy',
+            '净利润-季度环比增长': 'netprofit_qoq',
+            '销售毛利率': 'grossprofitmargin',
+            '每股净资产': 'bps',
+            '净资产收益率': 'roe',
+            '每股经营现金流量': 'ocf_per_share',
+            '最新公告日期': 'announce_date',
+        }
+
+        # symbol 已由 _fetch_and_cache 转换好，只选择需要的列
+        columns = ['symbol'] + [k for k in rename_map.keys() if k in df.columns]
+        result = df[columns].rename(columns=rename_map)
+
+        # 将 NaN 替换为 None（用于 MySQL）
+        import numpy as np
+        result = result.replace({np.nan: None})
+        return result
+
+    def get_lrb(self, date: str) -> pd.DataFrame:
+        """获取利润表数据
+
+        Args:
+            date: 财报日期，如 "20240630"
+
+        Returns:
+            包含所有股票的利润表数据
+        """
+        df = self._fetch_and_cache('lrb', date)
+        if df.empty:
+            return pd.DataFrame(columns=['symbol', 'net_profits', 'revenue'])
+
+        columns = ['symbol', 'net_profits', 'revenue']
+        available = [c for c in columns if c in df.columns]
+        return df[available].copy()
+
+    def get_zcfz(self, date: str) -> pd.DataFrame:
+        """获取资产负债表数据"""
+        df = self._fetch_and_cache('zcfz', date)
+        if df.empty:
+            return pd.DataFrame(columns=['symbol'])
+        return df[['symbol']].copy()
+
+    def get_xjll(self, date: str) -> pd.DataFrame:
+        """获取现金流量表数据"""
+        df = self._fetch_and_cache('xjll', date)
+        if df.empty:
+            return pd.DataFrame(columns=['symbol', 'ocf'])
+        columns = ['symbol', 'ocf']
+        available = [c for c in columns if c in df.columns]
+        return df[available].copy()
+
+    def get_all_reports(self, dates: List[str]) -> Dict[str, Dict[str, pd.DataFrame]]:
+        """批量获取多个日期的所有报表数据
+
+        Args:
+            dates: 财报日期列表，如 ["20240331", "20240630"]
+
+        Returns:
+            嵌套字典: {日期: {报表类型: DataFrame}}
+        """
+        result = {}
+        for d in dates:
+            result[d] = {
+                'yjbb': self.get_yjbb(d),
+                'lrb': self.get_lrb(d),
+                'zcfz': self.get_zcfz(d),
+                'xjll': self.get_xjll(d),
+            }
+        return result
+
+    def get_merged_fundamentals(self, dates: List[str]) -> pd.DataFrame:
+        """获取合并后的基本面数据
+
+        将多个日期的报表数据合并，按股票代码和报告日期对齐。
+
+        Args:
+            dates: 财报日期列表
+
+        Returns:
+            合并后的基本面数据 DataFrame
+        """
+        all_data = []
+
+        for d in dates:
+            # 只获取业绩报表，包含主要财务指标
+            yjbb = self.get_yjbb(d)
+
+            if yjbb.empty:
+                continue
+
+            # 重命名 YJBB 中的关键字段，匹配 MySQL 表结构
+            rename_map = {
+                '净资产收益率': 'roe',
+                '销售毛利率': 'grossprofitmargin',
+            }
+            merged = yjbb.copy()
+            for old_name, new_name in rename_map.items():
+                if old_name in merged.columns:
+                    merged = merged.rename(columns={old_name: new_name})
+
+            merged['report_date'] = d
+            all_data.append(merged)
+
+        if not all_data:
+            return pd.DataFrame()
+
+        return pd.concat(all_data, ignore_index=True)
+
+    @staticmethod
+    def generate_report_dates(start_year: int, end_year: int) -> List[str]:
+        """生成财报日期列表
+
+        Args:
+            start_year: 开始年份
+            end_year: 结束年份
+
+        Returns:
+            日期列表，如 ["20200331", "20200630", ...]
+        """
+        dates = []
+        for year in range(start_year, end_year + 1):
+            # 季度财报日期
+            dates.extend([
+                f"{year}0331",  # 一季报
+                f"{year}0630",  # 中报
+                f"{year}0930",  # 三季报
+                f"{year}1231",  # 年报
+            ])
+        return dates
+
+    def clear_cache(self, date: str = None):
+        """清除缓存
+
+        Args:
+            date: 指定日期则清除该日期缓存，默认清除全部
+        """
+        if date:
+            keys_to_remove = [k for k in self._cache if k.endswith(f"_{date}")]
+            for k in keys_to_remove:
+                del self._cache[k]
+            logger.info(f"已清除缓存: {date}")
+        else:
+            self._cache.clear()
+            logger.info("已清除全部缓存")
+
+    def get_cache_info(self) -> Dict[str, int]:
+        """获取缓存信息"""
+        return {
+            "cached_dates": len(self._cache),
+            "cache_keys": list(self._cache.keys())[:10],  # 只返回前10个
+        }

{quantcli-0.1.4 → quantcli-0.1.6}/quantcli/datasources/mysql.py

@@ -722,6 +722,174 @@ class MySQLDataSource(DataSource):
 
         logger.info(f"Synced {len(trading_days)} trading days")
 
+    def sync_fundamentals(
+        self,
+        start_year: int = 2020,
+        end_year: int = 2024
+    ):
+        """从 akshare 同步基本面数据到 MySQL（批量获取）
+
+        使用东方财富数据中心接口，一次获取指定日期的所有股票基本面数据。
+        计算 PE = avg_close / eps，PB = avg_close / bps
+
+        Args:
+            start_year: 开始年份
+            end_year: 结束年份
+        """
+        from .fundamentals import FundamentalsProvider
+
+        # 生成财报日期列表
+        dates = FundamentalsProvider.generate_report_dates(start_year, end_year)
+        logger.info(f"准备同步 {start_year}-{end_year} 年财报，共 {len(dates)} 个报告期")
+
+        # 使用 Provider 批量获取数据
+        provider = FundamentalsProvider(use_cache=True)
+        conn = self._get_connection()
+
+        total_inserted = 0
+        total_updated = 0
+
+        for report_date in dates:
+            logger.info(f"正在处理 {report_date}...")
+
+            # 获取合并后的基本面数据
+            df = provider.get_merged_fundamentals([report_date])
+
+            if df.empty:
+                logger.warning(f"{report_date} 无数据")
+                continue
+
+            logger.info(f"获取 {report_date} 数据 {len(df)} 条，计算 PE/PB...")
+
+            # 计算季度日均收盘价
+            # 财报截止日所在的季度：Q1(3月), Q2(6月), Q3(9月), Q4(12月)
+            month = int(report_date[4:6])
+            if month == 3:
+                quarter_start = f"{report_date[:4]}-01-01"
+                quarter_end = report_date
+            elif month == 6:
+                quarter_start = f"{report_date[:4]}-04-01"
+                quarter_end = report_date
+            elif month == 9:
+                quarter_start = f"{report_date[:4]}-07-01"
+                quarter_end = report_date
+            else:  # 12月
+                quarter_start = f"{report_date[:4]}-10-01"
+                quarter_end = report_date
+
+            # 获取季度日均收盘价
+            avg_prices = self._get_quarter_avg_close(df['symbol'].tolist(), quarter_start, quarter_end)
+
+            # 插入数据库
+            with conn.cursor() as cursor:
+                for _, row in df.iterrows():
+                    symbol = row.get('symbol')
+                    if not symbol:
+                        continue
+
+                    eps = row.get('eps')
+                    bps = row.get('bps')
+                    avg_close = avg_prices.get(symbol)
+
+                    # 转换为 float 避免 Decimal 运算问题
+                    eps_val = float(eps) if eps else None
+                    bps_val = float(bps) if bps else None
+                    avg_close_val = float(avg_close) if avg_close else None
+
+                    # 计算 PE 和 PB
+                    pe_ttm = None
+                    pb = None
+                    if avg_close_val and eps_val and eps_val != 0:
+                        pe_ttm = round(avg_close_val / eps_val, 2)
+                    if avg_close_val and bps_val and bps_val != 0:
+                        pb = round(avg_close_val / bps_val, 2)
+
+                    try:
+                        cursor.execute(f"""
+                            INSERT INTO {self._table('fundamental_data')}
+                            (symbol, report_date, eps, bps, net_profits, revenue, netprofit_yoy, roe, grossprofitmargin, pe_ttm, pb)
+                            VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
+                            ON DUPLICATE KEY UPDATE
+                            eps = COALESCE(VALUES(eps), eps),
+                            bps = COALESCE(VALUES(bps), bps),
+                            net_profits = COALESCE(VALUES(net_profits), net_profits),
+                            revenue = COALESCE(VALUES(revenue), revenue),
+                            netprofit_yoy = COALESCE(VALUES(netprofit_yoy), netprofit_yoy),
+                            roe = COALESCE(VALUES(roe), roe),
+                            grossprofitmargin = COALESCE(VALUES(grossprofitmargin), grossprofitmargin),
+                            pe_ttm = COALESCE(VALUES(pe_ttm), pe_ttm),
+                            pb = COALESCE(VALUES(pb), pb)
+                        """, (
+                            symbol,
+                            report_date,
+                            eps,
+                            bps,
+                            row.get('net_profits'),
+                            row.get('revenue'),
+                            row.get('netprofit_yoy'),
+                            row.get('roe'),
+                            row.get('grossprofitmargin'),
+                            pe_ttm,
+                            pb,
+                        ))
+                        total_inserted += 1
+                    except Exception as e:
+                        logger.warning(f"插入失败 {symbol}: {e}")
+
+            logger.info(f"{report_date} 完成")
+
+    def _get_quarter_avg_close(self, symbols: List[str], start_date: str, end_date: str) -> Dict[str, float]:
+        """计算股票在指定期间的日均收盘价
+
+        Args:
+            symbols: 股票代码列表
+            start_date: 开始日期
+            end_date: 结束日期
+
+        Returns:
+            {symbol: avg_close}
+        """
+        if not symbols:
+            return {}
+
+        conn = self._get_connection()
+        placeholders = ",".join(["%s"] * len(symbols))
+
+        sql = f"""
+            SELECT symbol, AVG(close) as avg_close
+            FROM {self._table('daily_prices')}
+            WHERE symbol IN ({placeholders})
+            AND trade_date BETWEEN %s AND %s
+            GROUP BY symbol
+        """
+
+        try:
+            with conn.cursor() as cursor:
+                cursor.execute(sql, tuple(symbols) + (start_date, end_date))
+                rows = cursor.fetchall()
+            return {row['symbol']: round(row['avg_close'], 2) for row in rows}
+        except Exception as e:
+            logger.warning(f"计算季度日均收盘价失败: {e}")
+            return {}
+
+        logger.info(f"基本面同步完成: 共插入/更新 {total_inserted} 条记录")
+
+    def sync_fundamentals_from_baostock(
+        self,
+        symbols: List[str] = None,
+        start_year: int = 2020,
+        end_year: int = 2024
+    ):
+        """从 baostock 同步基本面数据到 MySQL（已废弃，使用 sync_fundamentals）
+
+        Args:
+            symbols: 股票列表（默认同步所有）
+            start_year: 开始年份
+            end_year: 结束年份
+        """
+        logger.warning("sync_fundamentals_from_baostock 已废弃，请使用 sync_fundamentals")
+        self.sync_fundamentals(start_year, end_year)
+
     # ==================== 辅助方法 ====================
 
     def health_check(self) -> Dict[str, Any]:

{quantcli-0.1.4 → quantcli-0.1.6}/quantcli/datasources/sync/base.py

@@ -150,24 +150,24 @@ class DataSync(ABC):
 def create_sync(
     source: str,
     token: str = None,
-    mysql_host: str = None,
-    mysql_port: int = None,
-    mysql_user: str = None,
-    mysql_password: str = None,
-    mysql_database: str = None,
-    mysql_table_prefix: str = None,
+    host: str = None,
+    port: int = None,
+    user: str = None,
+    password: str = None,
+    database: str = None,
+    table_prefix: str = None,
 ) -> "DataSync":
     """创建同步器
 
     Args:
         source: 数据源名称 ("gm", "akshare", "baostock")
         token: API token (仅 gm 需要)
-        mysql_host: MySQL 主机地址
-        mysql_port: MySQL 端口
-        mysql_user: MySQL 用户名
-        mysql_password: MySQL 密码
-        mysql_database: MySQL 数据库名
-        mysql_table_prefix: 表前缀
+        host: MySQL 主机地址
+        port: MySQL 端口
+        user: MySQL 用户名
+        password: MySQL 密码
+        database: MySQL 数据库名
+        table_prefix: 表前缀
 
     Returns:
         DataSync 实例
@@ -184,20 +184,20 @@ def create_sync(
         >>> sync = create_sync(
         ...     "gm",
         ...     token="your_token",
-        ...     mysql_host="192.168.1.100",
-        ...     mysql_port=3307,
-        ...     mysql_user="quant",
-        ...     mysql_password="secret",
-        ...     mysql_database="quantdb",
-        ...     mysql_table_prefix="test_"
+        ...     host="192.168.1.100",
+        ...     port=3307,
+        ...     user="quant",
+        ...     password="secret",
+        ...     database="quantdb",
+        ...     table_prefix="test_"
         ... )
 
         >>> # 使用 akshare 同步到自定义数据库
         >>> sync = create_sync(
         ...     "akshare",
-        ...     mysql_host="localhost",
-        ...     mysql_database="mydata",
-        ...     mysql_table_prefix="prod_"
+        ...     host="localhost",
+        ...     database="mydata",
+        ...     table_prefix="prod_"
         ... )
     """
     from ..mysql import MySQLDataSource
@@ -206,12 +206,12 @@ def create_sync(
 
     # 创建 MySQL 数据源（传入连接参数）
     mysql = MySQLDataSource(
-        host=mysql_host,
-        port=mysql_port,
-        user=mysql_user,
-        password=mysql_password,
-        database=mysql_database,
-        table_prefix=mysql_table_prefix,
+        host=host,
+        port=port,
+        user=user,
+        password=password,
+        database=database,
+        table_prefix=table_prefix,
     )
 
     if source == "gm":

{quantcli-0.1.4 → quantcli-0.1.6}/quantcli/factors/screening_executor.py

@@ -56,7 +56,8 @@ class ScreeningExecutor:
     def run(
         self,
         symbols: Optional[List[str]] = None,
-        lookback_days: int = 30
+        lookback_days: int = 30,
+        as_of_date: Optional[date] = None,
     ) -> List[str]:
         """执行 screening
 
@@ -65,11 +66,15 @@ class ScreeningExecutor:
         Args:
             symbols: 初始股票列表（None 则从 stock_list 获取全部）
             lookback_days: 日线数据回溯天数
+            as_of_date: 指定日期（回测时使用，None 则使用 MySQL 最新日期）
 
         Returns:
             筛选后的股票代码列表
         """
-        end_date = self._get_last_trading_day()
+        if as_of_date:
+            end_date = as_of_date
+        else:
+            end_date = self._get_last_trading_day()
 
         # 1. 获取股票列表
         if symbols is None:
@@ -105,18 +110,21 @@ class ScreeningExecutor:
         return candidates
 
     def run_fundamental_only(
-        self,
-        symbols: Optional[List[str]] = None
+        self, symbols: Optional[List[str]] = None, as_of_date: Optional[date] = None
     ) -> List[str]:
         """仅执行基本面筛选
 
         Args:
             symbols: 初始股票列表
+            as_of_date: 指定日期（回测时使用，None 则使用 MySQL 最新日期）
 
         Returns:
             满足基本面条件的股票列表
         """
-        end_date = self._get_last_trading_day()
+        if as_of_date:
+            end_date = as_of_date
+        else:
+            end_date = self._get_last_trading_day()
 
         if symbols is None:
             symbols = self._get_stock_list()
@@ -126,18 +134,23 @@ class ScreeningExecutor:
     def run_daily_only(
         self,
         symbols: List[str],
-        lookback_days: int = 30
+        lookback_days: int = 30,
+        as_of_date: Optional[date] = None,
     ) -> List[str]:
         """仅执行日线筛选
 
         Args:
             symbols: 股票列表
             lookback_days: 回溯天数
+            as_of_date: 指定日期（回测时使用，None 则使用 MySQL 最新日期）
 
         Returns:
             满足日线条件的股票列表
         """
-        end_date = self._get_last_trading_day()
+        if as_of_date:
+            end_date = as_of_date
+        else:
+            end_date = self._get_last_trading_day()
         return self._daily_screening(symbols, end_date, lookback_days)
 
     def _get_stock_list(self) -> List[str]:
@@ -146,7 +159,7 @@ class ScreeningExecutor:
             df = self.mysql.get_stock_list()
             if df.empty:
                 return []
-            return df['symbol'].tolist()
+            return df["symbol"].tolist()
         except Exception as e:
             logger.error(f"获取股票列表失败: {e}")
             return []
@@ -163,11 +176,7 @@ class ScreeningExecutor:
         # 降级：返回昨天
         return date.today() - timedelta(1)
 
-    def _fundamental_screening(
-        self,
-        symbols: List[str],
-        end_date: date
-    ) -> List[str]:
+    def _fundamental_screening(self, symbols: List[str], end_date: date) -> List[str]:
         """基本面筛选"""
         conditions = self.config.screening.get("fundamental_conditions", [])
 
@@ -187,17 +196,12 @@ class ScreeningExecutor:
 
         # 应用别名并筛选
         processed_df = self.evaluator.apply_aliases(fundamental)
-        candidates = self.evaluator.filter_by_conditions(
-            conditions, processed_df
-        )
+        candidates = self.evaluator.filter_by_conditions(conditions, processed_df)
 
         return candidates
 
     def _daily_screening(
-        self,
-        symbols: List[str],
-        end_date: date,
-        lookback_days: int
+        self, symbols: List[str], end_date: date, lookback_days: int
     ) -> List[str]:
         """日线筛选"""
         conditions = self.config.screening.get("daily_conditions", [])
@@ -209,9 +213,7 @@ class ScreeningExecutor:
         try:
             start_date = end_date - timedelta(lookback_days)
             price_data = self.mysql.get_multi_daily(
-                symbols=symbols,
-                start_date=start_date,
-                end_date=end_date
+                symbols=symbols, start_date=start_date, end_date=end_date
             )
         except Exception as e:
             logger.error(f"获取日线数据失败: {e}")
@@ -227,7 +229,7 @@ class ScreeningExecutor:
             if df.empty:
                 continue
             df = df.copy()
-            df['symbol'] = symbol
+            df["symbol"] = symbol
             dfs.append(df)
 
         if not dfs:
@@ -236,15 +238,15 @@ class ScreeningExecutor:
         all_data = pd.concat(dfs, ignore_index=True)
 
         # 获取最新一天的数据
-        latest_date = all_data['date'].max()
-        latest_data = all_data[all_data['date'] == latest_date].copy()
+        latest_date = all_data["date"].max()
+        latest_data = all_data[all_data["date"] == latest_date].copy()
 
         if latest_data.empty:
             return symbols
 
         # 提取需要的因子
         factor_names = self.computer.get_factor_names_from_conditions(
-            conditions, {'close', 'open', 'high', 'low', 'volume', 'date', 'symbol'}
+            conditions, {"close", "open", "high", "low", "volume", "date", "symbol"}
         )
 
         if factor_names:
@@ -255,7 +257,7 @@ class ScreeningExecutor:
 
             # 将因子值写入 latest_data
             for symbol, values in computed_factors.items():
-                mask = latest_data['symbol'] == symbol
+                mask = latest_data["symbol"] == symbol
                 for name, value in values.items():
                     latest_data.loc[mask, name] = value
 
@@ -264,9 +266,10 @@ class ScreeningExecutor:
 
         # 收集通过的股票
         candidates = [
-            s for s in symbols
-            if s in latest_data['symbol'].values and
-            passed.get(latest_data[latest_data['symbol'] == s].index[0], True)
+            s
+            for s in symbols
+            if s in latest_data["symbol"].values
+            and passed.get(latest_data[latest_data["symbol"] == s].index[0], True)
         ]
 
         return candidates
@@ -275,7 +278,7 @@ class ScreeningExecutor:
         self,
         factor_names: List[str],
         price_data: Dict[str, pd.DataFrame],
-        symbols: List[str]
+        symbols: List[str],
     ) -> Dict[str, Dict[str, float]]:
         """为筛选条件计算因子值"""
         results = {}
@@ -297,6 +300,7 @@ class ScreeningExecutor:
                         continue
 
                     from ..parser import Formula
+
                     formula = Formula(factor.expr, name=factor_name)
                     result = formula.compute(df)
 
@@ -316,18 +320,20 @@ class ScreeningExecutor:
 
         for f in factors:
             # 支持因子对象或字典
-            if hasattr(f, 'name') and f.name == factor_name:
+            if hasattr(f, "name") and f.name == factor_name:
                 return f
-            elif isinstance(f, dict) and f.get('name') == factor_name:
+            elif isinstance(f, dict) and f.get("name") == factor_name:
                 from .base import FactorDefinition
+
                 return FactorDefinition(**f)
 
             # 支持路径匹配
             if factor_name in str(f).lower():
-                if hasattr(f, 'name'):
+                if hasattr(f, "name"):
                     return f
                 elif isinstance(f, dict):
                     from .base import FactorDefinition
+
                     return FactorDefinition(**f)
 
         return None

{quantcli-0.1.4 → quantcli-0.1.6/quantcli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quantcli
-Version: 0.1.4
+Version: 0.1.6
 Summary: 面向AI的多因子量化选股策略挖掘工具，AI Agent 友好 CLI
 Author-email: QuantCLI Team <quantcli@example.com>
 Project-URL: repository, https://github.com/wumu2013/quantcli

{quantcli-0.1.4 → quantcli-0.1.6}/quantcli.egg-info/SOURCES.txt

@@ -19,6 +19,8 @@ quantcli/datasources/base.py
 quantcli/datasources/cache.py
 quantcli/datasources/mixed.py
 quantcli/datasources/mysql.py
+quantcli/datasources/fundamentals/__init__.py
+quantcli/datasources/fundamentals/provider.py
 quantcli/datasources/sync/__init__.py
 quantcli/datasources/sync/akshare.py
 quantcli/datasources/sync/base.py