quantcli 0.1.17__tar.gz → 0.2.1__tar.gz

{quantcli-0.1.17/quantcli.egg-info → quantcli-0.2.1}/PKG-INFO

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

{quantcli-0.1.17 → quantcli-0.2.1}/pyproject.toml

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

{quantcli-0.1.17 → quantcli-0.2.1}/quantcli/core/data.py

@@ -117,16 +117,24 @@ class DataManager:
         """获取单只股票日线数据"""
         cache_file = self.cache_dir / "raw" / "stock_daily" / f"{symbol}.parquet"
 
-        # 检查缓存
-        if use_cache and cache_file.exists():
+        # 尝试获取交易日历，计算预期交易日数
+        expected_count = 0
+        has_calendar = False
+        try:
+            trading_days = self.get_trading_calendar()
+            expected_count = sum(1 for d in trading_days if start_date <= d <= end_date)
+            has_calendar = True
+        except Exception:
+            pass
+
+        # 检查缓存完整性
+        if use_cache and cache_file.exists() and has_calendar:
             cached = self._load_cached_range(cache_file)
-            if cached is not None:
+            if cached is not None and len(cached) >= expected_count:
                 mask = (cached["date"] >= start_date) & (cached["date"] <= end_date)
-                result = cached[mask].copy()
-                if not result.empty:
-                    return result
+                return cached[mask].copy()
 
-        # 从数据源获取
+        # 全量拉取
         df = self.datasource.get_daily(symbol, start_date, end_date, **kwargs)
 
         if df.empty:

{quantcli-0.1.17 → quantcli-0.2.1}/quantcli/datasources/akshare.py

@@ -235,13 +235,16 @@ class AkshareDataSource(DataSource):
         """获取交易日历"""
         if self.config.use_cache:
             cached = self._calendar_cache.get_calendar(exchange)
-            if cached is not None:
+            if cached is not None and self._validate_calendar(cached):
                 return sorted(pd.to_datetime(cached["trade_date"]).dt.date.tolist())
 
         df = self._ak.tool_trade_date_hist_sina()
         if df.empty:
             return []
 
+        if not self._validate_calendar(df):
+            return []
+
         trading_dates = pd.to_datetime(df["trade_date"]).dt.date.tolist()
 
         if self.config.use_cache:
@@ -249,6 +252,32 @@ class AkshareDataSource(DataSource):
 
         return sorted(trading_dates)
 
+    def _validate_calendar(self, df: pd.DataFrame) -> bool:
+        """验证交易日历是否完整"""
+        if df.empty:
+            return False
+
+        dates = pd.to_datetime(df["trade_date"])
+        min_date = dates.min()
+        max_date = dates.max()
+
+        # 检查日期范围（默认应该覆盖近1年）
+        from datetime import timedelta
+
+        one_year_ago = pd.Timestamp.now() - timedelta(days=365)
+
+        if min_date > one_year_ago:
+            return False
+
+        # 检查数量（1年应该有约250个交易日）
+        expected_min = 200
+        actual = len(dates)
+
+        if actual < expected_min:
+            return False
+
+        return True
+
     # ==================== 辅助方法 ====================
 
     def _filter_fields(

{quantcli-0.1.17 → quantcli-0.2.1/quantcli.egg-info}/PKG-INFO

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

{quantcli-0.1.17 → quantcli-0.2.1}/quantcli.egg-info/SOURCES.txt

@@ -89,6 +89,7 @@ quantcli/utils/validate.py
 tests/test_akshare_integration.py
 tests/test_builtin_factors.py
 tests/test_cli.py
+tests/test_data_manager.py
 tests/test_datasources.py
 tests/test_factors.py
 tests/test_gm_executors.py

{quantcli-0.1.17 → quantcli-0.2.1}/tests/test_cli.py

@@ -31,15 +31,17 @@ def mock_price_data():
     dates = pd.date_range(start=start_date, periods=100, freq="B")
 
     close = 100 + np.cumsum(np.random.randn(100) * 0.5)
-    return pd.DataFrame({
-        "date": dates,
-        "symbol": ["600519"] * 100,
-        "open": close * (1 + np.random.randn(100) * 0.005),
-        "high": close * (1 + np.abs(np.random.randn(100) * 0.01)),
-        "low": close * (1 - np.abs(np.random.randn(100) * 0.01)),
-        "close": close,
-        "volume": np.random.randint(1000000, 10000000, 100),
-    })
+    return pd.DataFrame(
+        {
+            "date": dates,
+            "symbol": ["600519"] * 100,
+            "open": close * (1 + np.random.randn(100) * 0.005),
+            "high": close * (1 + np.abs(np.random.randn(100) * 0.01)),
+            "low": close * (1 - np.abs(np.random.randn(100) * 0.01)),
+            "close": close,
+            "volume": np.random.randint(1000000, 10000000, 100),
+        }
+    )
 
 
 @pytest.fixture
@@ -58,17 +60,27 @@ class TestQuant3Main:
         result = runner.invoke(cli.quantcli, ["--help"])
         assert result.exit_code == 0
         assert "QuantCLI" in result.output
-        assert "quantitative" in result.output.lower() or "quant" in result.output.lower()
+        assert (
+            "quantitative" in result.output.lower() or "quant" in result.output.lower()
+        )
 
     def test_version(self, runner):
         """Test quantcli --version"""
         result = runner.invoke(cli.quantcli, ["--version"])
         assert result.exit_code == 0
-        assert "0.1.0" in result.output
+        assert "quantcli" in result.output.lower()
+        import re
+
+        match = re.search(r"version (\d+\.\d+\.\d+)", result.output)
+        assert match is not None
+        version = match.group(1)
+        assert re.match(r"\d+\.\d+\.\d+", version)
 
     def test_verbose_flag(self, runner):
         """Test verbose flag sets debug level"""
-        result = runner.invoke(cli.quantcli, ["--verbose", "data", "health"], catch_exceptions=False)
+        result = runner.invoke(
+            cli.quantcli, ["--verbose", "data", "health"], catch_exceptions=False
+        )
         # Should execute without error even if verbose mode
         assert result.exit_code == 0 or "Error" in result.output
 
@@ -81,8 +93,8 @@ class TestQuant3Main:
 class TestDataCommands:
     """Tests for data commands"""
 
-    @patch.object(cli.DataManager, '__init__')
-    @patch.object(cli.DataManager, 'get_daily')
+    @patch.object(cli.DataManager, "__init__")
+    @patch.object(cli.DataManager, "get_daily")
     def test_data_fetch_basic(self, mock_get_daily, mock_init, runner, mock_price_data):
         """Test data fetch command"""
         mock_init.return_value = None
@@ -93,42 +105,43 @@ class TestDataCommands:
         assert result.exit_code == 0
         assert "600519" in result.output
 
-    @patch.object(cli.DataManager, '__init__')
-    @patch.object(cli.DataManager, 'get_daily')
-    def test_data_fetch_with_dates(self, mock_get_daily, mock_init, runner, mock_price_data):
+    @patch.object(cli.DataManager, "__init__")
+    @patch.object(cli.DataManager, "get_daily")
+    def test_data_fetch_with_dates(
+        self, mock_get_daily, mock_init, runner, mock_price_data
+    ):
         """Test data fetch with start and end dates"""
         mock_init.return_value = None
         mock_get_daily.return_value = mock_price_data
 
-        result = runner.invoke(cli.data_fetch, [
-            "600519",
-            "--start", "2023-01-01",
-            "--end", "2023-06-01"
-        ])
+        result = runner.invoke(
+            cli.data_fetch, ["600519", "--start", "2023-01-01", "--end", "2023-06-01"]
+        )
 
         assert result.exit_code == 0
         assert "2023-01-01" in result.output or "2023-06-01" in result.output
 
-    @patch.object(cli.DataManager, '__init__')
-    @patch.object(cli.DataManager, 'get_daily')
-    def test_data_fetch_with_output_csv(self, mock_get_daily, mock_init, runner, mock_price_data, tmp_path):
+    @patch.object(cli.DataManager, "__init__")
+    @patch.object(cli.DataManager, "get_daily")
+    def test_data_fetch_with_output_csv(
+        self, mock_get_daily, mock_init, runner, mock_price_data, tmp_path
+    ):
         """Test data fetch with CSV output"""
         mock_init.return_value = None
         mock_get_daily.return_value = mock_price_data
 
         output_file = tmp_path / "output.csv"
 
-        result = runner.invoke(cli.data_fetch, [
-            "600519",
-            "--start", "2023-01-01",
-            "--output", str(output_file)
-        ])
+        result = runner.invoke(
+            cli.data_fetch,
+            ["600519", "--start", "2023-01-01", "--output", str(output_file)],
+        )
 
         assert result.exit_code == 0
         assert "Saved to" in result.output
 
-    @patch.object(cli.DataManager, '__init__')
-    @patch.object(cli.DataManager, 'get_daily')
+    @patch.object(cli.DataManager, "__init__")
+    @patch.object(cli.DataManager, "get_daily")
     def test_data_fetch_empty_result(self, mock_get_daily, mock_init, runner):
         """Test data fetch with no data"""
         mock_init.return_value = None
@@ -146,15 +159,15 @@ class TestDataCommands:
         assert result.exit_code != 0
         assert "Invalid date" in result.output or "Error" in result.output
 
-    @patch.object(cli.DataManager, '__init__')
-    @patch.object(cli.DataManager, 'get_cache_size')
+    @patch.object(cli.DataManager, "__init__")
+    @patch.object(cli.DataManager, "get_cache_size")
     def test_data_cache_ls(self, mock_get_cache_size, mock_init, runner):
         """Test data cache list command"""
         mock_init.return_value = None
         mock_get_cache_size.return_value = {
             "600519.csv": "1.2MB",
             "000001.csv": "0.8MB",
-            "_total": "2.0MB"
+            "_total": "2.0MB",
         }
 
         result = runner.invoke(cli.data_cache_ls, [])
@@ -162,8 +175,8 @@ class TestDataCommands:
         assert result.exit_code == 0
         assert "Cached files" in result.output or "600519" in result.output
 
-    @patch.object(cli.DataManager, '__init__')
-    @patch.object(cli.DataManager, 'clear_cache')
+    @patch.object(cli.DataManager, "__init__")
+    @patch.object(cli.DataManager, "clear_cache")
     def test_data_cache_clean(self, mock_clear_cache, mock_init, runner):
         """Test data cache clean command"""
         mock_init.return_value = None
@@ -174,15 +187,15 @@ class TestDataCommands:
         assert result.exit_code == 0
         assert "5" in result.output or "Cleaned" in result.output
 
-    @patch.object(cli.DataManager, '__init__')
-    @patch.object(cli.DataManager, 'health_check')
+    @patch.object(cli.DataManager, "__init__")
+    @patch.object(cli.DataManager, "health_check")
     def test_data_health(self, mock_health_check, mock_init, runner):
         """Test data health check command"""
         mock_init.return_value = None
         mock_health_check.return_value = {
             "status": "ok",
             "cache_dir": "/tmp/quantcli_cache",
-            "source": "akshare"
+            "source": "akshare",
         }
 
         result = runner.invoke(cli.data_health, [])
@@ -194,87 +207,117 @@ class TestDataCommands:
 class TestFactorCommands:
     """Tests for factor commands"""
 
-    @patch.object(cli.DataManager, '__init__')
-    @patch.object(cli.DataManager, 'get_daily')
+    @patch.object(cli.DataManager, "__init__")
+    @patch.object(cli.DataManager, "get_daily")
     def test_factor_run_basic(self, mock_get_daily, mock_init, runner, mock_price_data):
         """Test factor run command with basic formula"""
         mock_init.return_value = None
         mock_get_daily.return_value = mock_price_data
 
-        result = runner.invoke(cli.factor_run, [
-            "--name", "momentum",
-            "--expr", "(close / delay(close, 20)) - 1",
-            "--symbol", "600519",
-            "--start", "2023-01-01"
-        ])
+        result = runner.invoke(
+            cli.factor_run,
+            [
+                "--name",
+                "momentum",
+                "--expr",
+                "(close / delay(close, 20)) - 1",
+                "--symbol",
+                "600519",
+                "--start",
+                "2023-01-01",
+            ],
+        )
 
         assert result.exit_code == 0
         assert "momentum" in result.output or "computed" in result.output.lower()
 
-    @patch.object(cli.DataManager, '__init__')
-    @patch.object(cli.DataManager, 'get_daily')
-    def test_factor_run_with_ma(self, mock_get_daily, mock_init, runner, mock_price_data):
+    @patch.object(cli.DataManager, "__init__")
+    @patch.object(cli.DataManager, "get_daily")
+    def test_factor_run_with_ma(
+        self, mock_get_daily, mock_init, runner, mock_price_data
+    ):
         """Test factor run with moving average formula"""
         mock_init.return_value = None
         mock_get_daily.return_value = mock_price_data
 
-        result = runner.invoke(cli.factor_run, [
-            "--name", "ma_20",
-            "--expr", "ma(close, 20)",
-            "--symbol", "600519",
-            "--start", "2023-01-01"
-        ])
+        result = runner.invoke(
+            cli.factor_run,
+            [
+                "--name",
+                "ma_20",
+                "--expr",
+                "ma(close, 20)",
+                "--symbol",
+                "600519",
+                "--start",
+                "2023-01-01",
+            ],
+        )
 
         assert result.exit_code == 0
         assert "ma_20" in result.output or "computed" in result.output.lower()
 
-    @patch.object(cli.DataManager, '__init__')
-    @patch.object(cli.DataManager, 'get_daily')
-    def test_factor_run_with_output(self, mock_get_daily, mock_init, runner, mock_price_data, tmp_path):
+    @patch.object(cli.DataManager, "__init__")
+    @patch.object(cli.DataManager, "get_daily")
+    def test_factor_run_with_output(
+        self, mock_get_daily, mock_init, runner, mock_price_data, tmp_path
+    ):
         """Test factor run with CSV output"""
         mock_init.return_value = None
         mock_get_daily.return_value = mock_price_data
 
         output_file = tmp_path / "factor_output.csv"
 
-        result = runner.invoke(cli.factor_run, [
-            "--name", "momentum",
-            "--expr", "close - close",
-            "--symbol", "600519",
-            "--start", "2023-01-01",
-            "--output", str(output_file)
-        ])
+        result = runner.invoke(
+            cli.factor_run,
+            [
+                "--name",
+                "momentum",
+                "--expr",
+                "close - close",
+                "--symbol",
+                "600519",
+                "--start",
+                "2023-01-01",
+                "--output",
+                str(output_file),
+            ],
+        )
 
         assert result.exit_code == 0
         assert "Saved to" in result.output
 
-    @patch.object(cli.DataManager, '__init__')
-    @patch.object(cli.DataManager, 'get_daily')
-    @patch.object(cli.FactorEngine, 'evaluate_ic')
-    def test_factor_eval_ic(self, mock_eval_ic, mock_get_daily, mock_init, runner, mock_price_data):
+    @patch.object(cli.DataManager, "__init__")
+    @patch.object(cli.DataManager, "get_daily")
+    @patch.object(cli.FactorEngine, "evaluate_ic")
+    def test_factor_eval_ic(
+        self, mock_eval_ic, mock_get_daily, mock_init, runner, mock_price_data
+    ):
         """Test factor eval with IC method"""
         mock_init.return_value = None
         mock_get_daily.return_value = mock_price_data
         mock_eval_ic.return_value = {
-            "ic_stats": {
-                "ic_mean": 0.05,
-                "ic_std": 0.15,
-                "ic_ir": 0.33
-            }
+            "ic_stats": {"ic_mean": 0.05, "ic_std": 0.15, "ic_ir": 0.33}
         }
 
-        result = runner.invoke(cli.factor_eval, [
-            "momentum",
-            "--symbol", "600519",
-            "--start", "2023-01-01",
-            "--method", "ic"
-        ])
+        result = runner.invoke(
+            cli.factor_eval,
+            [
+                "momentum",
+                "--symbol",
+                "600519",
+                "--start",
+                "2023-01-01",
+                "--method",
+                "ic",
+            ],
+        )
 
         assert result.exit_code == 0
         assert "IC" in result.output or "IC Mean" in result.output
 
-    @patch.object(cli.DataManager, '__init__')
-    @patch.object(cli.DataManager, 'get_daily')
+    @patch.object(cli.DataManager, "__init__")
+    @patch.object(cli.DataManager, "get_daily")
     def test_factor_list(self, mock_get_daily, mock_init, runner):
         """Test factor list command"""
         mock_init.return_value = None
@@ -289,9 +332,11 @@ class TestFactorCommands:
 class TestBacktestCommands:
     """Tests for backtest commands"""
 
-    @patch.object(cli.DataManager, '__init__')
-    @patch.object(cli.DataManager, 'get_daily')
-    def test_backtest_run_ma_cross(self, mock_get_daily, mock_init, runner, mock_price_data):
+    @patch.object(cli.DataManager, "__init__")
+    @patch.object(cli.DataManager, "get_daily")
+    def test_backtest_run_ma_cross(
+        self, mock_get_daily, mock_init, runner, mock_price_data
+    ):
         """Test backtest run with built-in MA cross strategy
 
         Note: May fail due to existing backtest engine issues with order handling.
@@ -300,39 +345,47 @@ class TestBacktestCommands:
         mock_get_daily.return_value = mock_price_data
 
         # Use built-in strategy
-        result = runner.invoke(cli.backtest_run, [
-            "--strategy", "ma_cross",
-            "--symbol", "600519",
-            "--start", "2023-01-01"
-        ])
+        result = runner.invoke(
+            cli.backtest_run,
+            ["--strategy", "ma_cross", "--symbol", "600519", "--start", "2023-01-01"],
+        )
 
         # Either succeeds or fails with known backtest engine issue
         # Check that it attempted to run backtest
         assert "Running backtest" in result.output or "Error" in result.output
 
-    @patch.object(cli.DataManager, '__init__')
-    @patch.object(cli.DataManager, 'get_daily')
-    def test_backtest_run_with_custom_capital(self, mock_get_daily, mock_init, runner, mock_price_data):
+    @patch.object(cli.DataManager, "__init__")
+    @patch.object(cli.DataManager, "get_daily")
+    def test_backtest_run_with_custom_capital(
+        self, mock_get_daily, mock_init, runner, mock_price_data
+    ):
         """Test backtest run with custom capital"""
         mock_init.return_value = None
         mock_get_daily.return_value = mock_price_data
 
-        result = runner.invoke(cli.backtest_run, [
-            "--strategy", "ma_cross",
-            "--symbol", "600519",
-            "--start", "2023-01-01",
-            "--capital", "500000"
-        ])
+        result = runner.invoke(
+            cli.backtest_run,
+            [
+                "--strategy",
+                "ma_cross",
+                "--symbol",
+                "600519",
+                "--start",
+                "2023-01-01",
+                "--capital",
+                "500000",
+            ],
+        )
 
         # Either succeeds or fails with known backtest engine issue
         assert "Running backtest" in result.output or "Error" in result.output
 
     def test_backtest_run_invalid_strategy(self, runner):
         """Test backtest run with invalid strategy"""
-        result = runner.invoke(cli.backtest_run, [
-            "--strategy", "nonexistent_strategy",
-            "--symbol", "600519"
-        ])
+        result = runner.invoke(
+            cli.backtest_run,
+            ["--strategy", "nonexistent_strategy", "--symbol", "600519"],
+        )
 
         assert result.exit_code != 0
         assert "Error" in result.output or "Unknown strategy" in result.output
@@ -348,7 +401,7 @@ class TestBacktestCommands:
 class TestConfigCommands:
     """Tests for config commands"""
 
-    @patch.object(cli.DataManager, '__init__')
+    @patch.object(cli.DataManager, "__init__")
     def test_config_show(self, mock_init, runner):
         """Test config show command"""
         mock_init.return_value = None
@@ -372,20 +425,26 @@ class TestDateType:
 
     def test_valid_date(self, runner):
         """Test valid date format"""
-        result = runner.invoke(cli.quantcli, ["data", "fetch", "600519", "--start", "2023-12-31"])
+        result = runner.invoke(
+            cli.quantcli, ["data", "fetch", "600519", "--start", "2023-12-31"]
+        )
         # Should not fail on date parsing
         assert "Error" not in result.output or result.exit_code == 0
 
     def test_invalid_date_format(self, runner):
         """Test invalid date format"""
-        result = runner.invoke(cli.quantcli, ["data", "fetch", "600519", "--start", "31-12-2023"])
+        result = runner.invoke(
+            cli.quantcli, ["data", "fetch", "600519", "--start", "31-12-2023"]
+        )
 
         assert result.exit_code != 0
         assert "Invalid date" in result.output or "Error" in result.output
 
     def test_invalid_date_value(self, runner):
         """Test invalid date value"""
-        result = runner.invoke(cli.quantcli, ["data", "fetch", "600519", "--start", "2023-13-01"])
+        result = runner.invoke(
+            cli.quantcli, ["data", "fetch", "600519", "--start", "2023-13-01"]
+        )
 
         assert result.exit_code != 0
 
@@ -393,19 +452,26 @@ class TestDateType:
 class TestEdgeCases:
     """Tests for edge cases and error handling"""
 
-    @patch.object(cli.DataManager, '__init__')
-    @patch.object(cli.DataManager, 'get_daily')
+    @patch.object(cli.DataManager, "__init__")
+    @patch.object(cli.DataManager, "get_daily")
     def test_factor_run_empty_data(self, mock_get_daily, mock_init, runner):
         """Test factor run with empty data"""
         mock_init.return_value = None
         mock_get_daily.return_value = pd.DataFrame()
 
-        result = runner.invoke(cli.factor_run, [
-            "--name", "test_factor",
-            "--expr", "close",
-            "--symbol", "600519",
-            "--start", "2023-01-01"
-        ])
+        result = runner.invoke(
+            cli.factor_run,
+            [
+                "--name",
+                "test_factor",
+                "--expr",
+                "close",
+                "--symbol",
+                "600519",
+                "--start",
+                "2023-01-01",
+            ],
+        )
 
         assert result.exit_code == 0
         assert "No data" in result.output
@@ -420,12 +486,12 @@ screening:
   conditions: []
 """)
 
-        with patch('quantcli.core.backtest.YAMLBacktestEngine.run') as mock_run:
+        with patch("quantcli.core.backtest.YAMLBacktestEngine.run") as mock_run:
             mock_run.side_effect = Exception("No data")
-            result = runner.invoke(cli.backtest_run, [
-                "--strategy", str(strategy_file),
-                "--start", "2023-01-01"
-            ])
+            result = runner.invoke(
+                cli.backtest_run,
+                ["--strategy", str(strategy_file), "--start", "2023-01-01"],
+            )
 
             # Should fail due to no data
             assert result.exit_code != 0