rquote 0.4.0__tar.gz → 0.4.2__tar.gz

{rquote-0.4.0 → rquote-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rquote
-Version: 0.4.0
+Version: 0.4.2
 Summary: Mostly day quotes of cn/hk/us/fund/future markets, side with quote list fetch
 Requires-Python: >=3.9.0
 Description-Content-Type: text/markdown
@@ -18,7 +18,7 @@ Requires-Dist: duckdb>=0.9.0; extra == "persistent"
 
 ## 版本信息
 
-当前版本：**0.3.5**
+当前版本：**0.4.2**
 
 ## 主要特性
 
@@ -199,13 +199,13 @@ stocks = get_cn_stock_list(money_min=5e8)
 
 #### `get_hk_stocks_500()`
 
-获取港股前500只股票列表
+获取港股前500只股票列表(按当日成交额排序)
 
 ```python
 from rquote import get_hk_stocks_500
 
 stocks = get_hk_stocks_500()
-# 返回格式: [[code, name, price, turnover, ...], ...]
+# 返回格式: [[code, name, price, -, -, -, -, volume, turnover, ...], ...]
 ```
 
 #### `get_us_stocks(k=100)`

{rquote-0.4.0 → rquote-0.4.2}/README.md

@@ -4,7 +4,7 @@
 
 ## 版本信息
 
-当前版本：**0.3.5**
+当前版本：**0.4.2**
 
 ## 主要特性
 
@@ -185,13 +185,13 @@ stocks = get_cn_stock_list(money_min=5e8)
 
 #### `get_hk_stocks_500()`
 
-获取港股前500只股票列表
+获取港股前500只股票列表(按当日成交额排序)
 
 ```python
 from rquote import get_hk_stocks_500
 
 stocks = get_hk_stocks_500()
-# 返回格式: [[code, name, price, turnover, ...], ...]
+# 返回格式: [[code, name, price, -, -, -, -, volume, turnover, ...], ...]
 ```
 
 #### `get_us_stocks(k=100)`

{rquote-0.4.0 → rquote-0.4.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "rquote"
-version = "0.4.0"
+version = "0.4.2"
 description = "Mostly day quotes of cn/hk/us/fund/future markets, side with quote list fetch"
 readme = "README.md"
 # requires-python = ">=3.6.1" # duckdb requires higher python version

{rquote-0.4.0 → rquote-0.4.2}/rquote/cache/persistent.py

@@ -9,6 +9,13 @@ from typing import Optional, Any, Tuple
 import pandas as pd
 from .base import Cache
 
+# 导入日志
+try:
+    from ..utils.logging import logger
+except ImportError:
+    import logging
+    logger = logging.getLogger(__name__)
+
 # 尝试导入 duckdb（可选依赖）
 try:
     import duckdb
@@ -125,8 +132,20 @@ class PersistentCache(Cache):
     
     def _get_dataframe_date_range(self, df: pd.DataFrame) -> Tuple[Optional[pd.Timestamp], Optional[pd.Timestamp]]:
         """获取 DataFrame 的日期范围"""
-        if df.empty or not isinstance(df.index, pd.DatetimeIndex):
+        if df.empty:
+            return None, None
+        
+        # 如果索引不是 DatetimeIndex，尝试转换
+        if not isinstance(df.index, pd.DatetimeIndex):
+            try:
+                # 尝试转换为 DatetimeIndex
+                index = pd.to_datetime(df.index)
+                if len(index) > 0:
+                    return index.min(), index.max()
+            except (ValueError, TypeError):
+                pass
             return None, None
+        
         return df.index.min(), df.index.max()
     
     def _filter_dataframe_by_date(self, df: pd.DataFrame, sdate: Optional[str] = None, 
@@ -164,29 +183,56 @@ class PersistentCache(Cache):
         combined = combined.sort_index()
         return combined
     
-    def get(self, key: str) -> Optional[Any]:
+    def get(self, key: str, sdate: Optional[str] = None, edate: Optional[str] = None) -> Optional[Any]:
         """
         获取缓存数据
         
         Args:
-            key: 缓存 key，格式如 "symbol:sdate:edate:freq:days:fq"
+            key: 缓存 key，可以是完整格式 "symbol:sdate:edate:freq:days:fq" 
+                 或 base_key 格式 "symbol:freq:fq"
+            sdate: 开始日期（可选，如果 key 是 base_key 格式则必须提供）
+            edate: 结束日期（可选，如果 key 是 base_key 格式则必须提供）
         
         Returns:
             (symbol, name, DataFrame) 或 None
         """
-        symbol, sdate, edate, freq, fq = self._extract_key_parts(key)
-        base_key = self._get_base_key(symbol, freq, fq)
+        # 判断 key 格式：如果是 base_key 格式（只有3部分），使用参数中的日期
+        parts = key.split(':')
+        if len(parts) == 3:
+            # base_key 格式：symbol:freq:fq
+            symbol, freq, fq = parts
+            base_key = key
+            # 使用参数中的日期，如果没有则使用空字符串
+            sdate = sdate or ''
+            edate = edate or ''
+        else:
+            # 完整 key 格式：symbol:sdate:edate:freq:days:fq
+            symbol, sdate_from_key, edate_from_key, freq, fq = self._extract_key_parts(key)
+            base_key = self._get_base_key(symbol, freq, fq)
+            # 优先使用参数中的日期，如果没有则使用 key 中的日期
+            sdate = sdate if sdate is not None else sdate_from_key
+            edate = edate if edate is not None else edate_from_key
+        
+        logger.info(f"[CACHE GET] key={key}, base_key={base_key}, sdate={sdate}, edate={edate}")
         
         if self.use_duckdb:
-            return self._get_duckdb(base_key, symbol, sdate, edate, freq, fq)
+            result = self._get_duckdb(base_key, symbol, sdate, edate, freq, fq)
+        else:
+            result = self._get_pickle(base_key, symbol, sdate, edate, freq, fq)
+        
+        if result:
+            _, _, df = result
+            logger.info(f"[CACHE HIT] key={key}, 返回数据行数={len(df)}, 日期范围={df.index.min()} 到 {df.index.max()}")
         else:
-            return self._get_pickle(base_key, symbol, sdate, edate, freq, fq)
+            logger.info(f"[CACHE MISS] key={key}, 缓存中无数据")
+        
+        return result
     
     def _get_duckdb(self, base_key: str, symbol: str, sdate: str, edate: str, 
                     freq: str, fq: str) -> Optional[Tuple[str, str, pd.DataFrame]]:
         """从 duckdb 获取数据"""
         result = self.conn.execute("""
-            SELECT name, data, earliest_date, latest_date, expire_at
+            SELECT name, data, expire_at
             FROM cache_data
             WHERE cache_key = ?
         """, [base_key]).fetchone()
@@ -194,7 +240,7 @@ class PersistentCache(Cache):
         if not result:
             return None
         
-        name, data_blob, earliest_date, latest_date, expire_at = result
+        name, data_blob, expire_at = result
         
         # 检查过期
         if self.ttl and expire_at:
@@ -207,33 +253,40 @@ class PersistentCache(Cache):
         import pickle
         df = pickle.loads(data_blob)
         
-        # 获取缓存数据的日期范围
-        cached_earliest = self._parse_date(earliest_date)
-        cached_latest = self._parse_date(latest_date)
+        # 确保索引是 DatetimeIndex
+        if not isinstance(df.index, pd.DatetimeIndex):
+            try:
+                df.index = pd.to_datetime(df.index)
+            except (ValueError, TypeError):
+                return None
+        
+        if df.empty:
+            return None
+        
+        # 直接从 DataFrame 索引获取实际的日期范围
+        cached_earliest = df.index.min()
+        cached_latest = df.index.max()
         
-        # 如果请求的日期范围完全在缓存范围内，直接返回过滤后的数据
+        # 解析请求的日期范围
         request_sdate = self._parse_date(sdate) if sdate else None
         request_edate = self._parse_date(edate) if edate else None
         
-        # 检查是否有重叠
-        if request_edate and cached_earliest and request_edate < cached_earliest:
+        # 检查是否有重叠：如果请求的日期范围与缓存数据有重叠，就返回过滤后的数据
+        # 注意：即使缓存中有部分数据，也应该返回（让上层决定是否需要扩展）
+        has_overlap = True
+        if request_edate and request_edate < cached_earliest:
             # 请求的结束日期早于缓存的最早日期，无重叠
-            return None
-        if request_sdate and cached_latest and request_sdate > cached_latest:
+            has_overlap = False
+        if request_sdate and request_sdate > cached_latest:
             # 请求的开始日期晚于缓存的最晚日期，无重叠
-            return None
+            has_overlap = False
         
-        # 有重叠，返回缓存中可用的部分数据
-        # 计算实际可用的日期范围
-        actual_sdate = max(request_sdate, cached_earliest) if request_sdate and cached_earliest else (request_sdate or cached_earliest)
-        actual_edate = min(request_edate, cached_latest) if request_edate and cached_latest else (request_edate or cached_latest)
+        if not has_overlap:
+            return None
         
-        # 过滤数据
-        filtered_df = self._filter_dataframe_by_date(
-            df, 
-            actual_sdate.strftime('%Y-%m-%d') if actual_sdate else None,
-            actual_edate.strftime('%Y-%m-%d') if actual_edate else None
-        )
+        # 按照请求的日期范围过滤数据（即使缓存中有更多数据，也只返回请求范围内的）
+        # 重要：必须按照 edate 截取，和从网络获取的行为一致
+        filtered_df = self._filter_dataframe_by_date(df, sdate, edate)
         
         if filtered_df.empty:
             return None
@@ -258,36 +311,41 @@ class PersistentCache(Cache):
         
         df = cache_entry['data']
         name = cache_entry.get('name', '')
-        earliest_date = cache_entry.get('earliest_date')
-        latest_date = cache_entry.get('latest_date')
         
-        # 获取缓存数据的日期范围
-        cached_earliest = self._parse_date(earliest_date)
-        cached_latest = self._parse_date(latest_date)
+        # 确保索引是 DatetimeIndex
+        if not isinstance(df.index, pd.DatetimeIndex):
+            try:
+                df.index = pd.to_datetime(df.index)
+            except (ValueError, TypeError):
+                return None
+        
+        if df.empty:
+            return None
+        
+        # 直接从 DataFrame 索引获取实际的日期范围
+        cached_earliest = df.index.min()
+        cached_latest = df.index.max()
         
-        # 如果请求的日期范围完全在缓存范围内，直接返回过滤后的数据
+        # 解析请求的日期范围
         request_sdate = self._parse_date(sdate) if sdate else None
         request_edate = self._parse_date(edate) if edate else None
         
-        # 检查是否有重叠
-        if request_edate and cached_earliest and request_edate < cached_earliest:
+        # 检查是否有重叠：如果请求的日期范围与缓存数据有重叠，就返回过滤后的数据
+        # 注意：即使缓存中有部分数据，也应该返回（让上层决定是否需要扩展）
+        has_overlap = True
+        if request_edate and request_edate < cached_earliest:
             # 请求的结束日期早于缓存的最早日期，无重叠
-            return None
-        if request_sdate and cached_latest and request_sdate > cached_latest:
+            has_overlap = False
+        if request_sdate and request_sdate > cached_latest:
             # 请求的开始日期晚于缓存的最晚日期，无重叠
-            return None
+            has_overlap = False
         
-        # 有重叠，返回缓存中可用的部分数据
-        # 计算实际可用的日期范围
-        actual_sdate = max(request_sdate, cached_earliest) if request_sdate and cached_earliest else (request_sdate or cached_earliest)
-        actual_edate = min(request_edate, cached_latest) if request_edate and cached_latest else (request_edate or cached_latest)
+        if not has_overlap:
+            return None
         
-        # 过滤数据
-        filtered_df = self._filter_dataframe_by_date(
-            df,
-            actual_sdate.strftime('%Y-%m-%d') if actual_sdate else None,
-            actual_edate.strftime('%Y-%m-%d') if actual_edate else None
-        )
+        # 按照请求的日期范围过滤数据（即使缓存中有更多数据，也只返回请求范围内的）
+        # 重要：必须按照 edate 截取，和从网络获取的行为一致
+        filtered_df = self._filter_dataframe_by_date(df, sdate, edate)
         
         if filtered_df.empty:
             return None
@@ -299,7 +357,8 @@ class PersistentCache(Cache):
         存储缓存数据
         
         Args:
-            key: 缓存 key
+            key: 缓存 key，可以是完整格式 "symbol:sdate:edate:freq:days:fq" 
+                 或 base_key 格式 "symbol:freq:fq"（推荐使用 base_key）
             value: (symbol, name, DataFrame) 元组
             ttl: 过期时间（秒）
         """
@@ -310,8 +369,25 @@ class PersistentCache(Cache):
         if not isinstance(df, pd.DataFrame) or df.empty:
             return
         
-        _, _, _, freq, fq = self._extract_key_parts(key)
-        base_key = self._get_base_key(symbol, freq, fq)
+        logger.info(f"[CACHE PUT] key={key}, 数据行数={len(df)}, 日期范围={df.index.min() if not df.empty else 'N/A'} 到 {df.index.max() if not df.empty else 'N/A'}")
+        
+        # 确保索引是 DatetimeIndex（用于正确获取日期范围）
+        if not isinstance(df.index, pd.DatetimeIndex):
+            try:
+                df.index = pd.to_datetime(df.index)
+            except (ValueError, TypeError):
+                pass  # 如果转换失败，继续处理（_get_dataframe_date_range 会处理）
+        
+        # 判断 key 格式：如果是 base_key 格式（只有3部分），直接使用
+        parts = key.split(':')
+        if len(parts) == 3:
+            # base_key 格式：symbol:freq:fq
+            base_key = key
+            freq, fq = parts[1], parts[2]
+        else:
+            # 完整 key 格式：symbol:sdate:edate:freq:days:fq
+            _, _, _, freq, fq = self._extract_key_parts(key)
+            base_key = self._get_base_key(symbol, freq, fq)
         
         # 尝试从基础 key 获取完整数据并合并
         existing = self._get_raw(base_key)
@@ -322,6 +398,12 @@ class PersistentCache(Cache):
                 name = existing_name
             # 合并数据
             df = self._merge_dataframes(existing_df, df)
+            # 合并后再次确保索引是 DatetimeIndex
+            if not isinstance(df.index, pd.DatetimeIndex):
+                try:
+                    df.index = pd.to_datetime(df.index)
+                except (ValueError, TypeError):
+                    pass
         
         # 获取日期范围
         earliest_date, latest_date = self._get_dataframe_date_range(df)
@@ -338,6 +420,8 @@ class PersistentCache(Cache):
             self._put_duckdb(base_key, symbol, name, df, earliest_str, latest_str, freq, fq, expire_at)
         else:
             self._put_pickle(base_key, symbol, name, df, earliest_str, latest_str, freq, fq, expire_at)
+        
+        logger.info(f"[CACHE PUT] 存储完成, base_key={base_key}, 日期范围={earliest_str} 到 {latest_str}")
     
     def _get_raw(self, base_key: str) -> Optional[Tuple[str, str, pd.DataFrame]]:
         """获取原始数据（不进行日期过滤）"""
@@ -363,7 +447,10 @@ class PersistentCache(Cache):
     def _put_duckdb(self, base_key: str, symbol: str, name: str, df: pd.DataFrame,
                      earliest_date: Optional[str], latest_date: Optional[str],
                      freq: str, fq: str, expire_at: Optional[pd.Timestamp]):
-        """存储到 duckdb"""
+        """存储到 duckdb
+        
+        注意：earliest_date 和 latest_date 仅用于记录，实际查询时从 DataFrame 索引获取
+        """
         import pickle
         data_blob = pickle.dumps(df)
         

{rquote-0.4.0 → rquote-0.4.2}/rquote/markets/base.py

@@ -9,6 +9,13 @@ from datetime import datetime, timedelta
 from ..cache import Cache
 from ..data_sources.base import DataSource
 
+# 导入日志
+try:
+    from ..utils.logging import logger
+except ImportError:
+    import logging
+    logger = logging.getLogger(__name__)
+
 # 尝试导入持久化缓存（可选依赖）
 try:
     from ..cache.persistent import PersistentCache
@@ -84,10 +91,23 @@ class Market(ABC):
         """标准化股票代码"""
         pass
     
-    def _get_cached(self, key: str) -> Optional[Tuple[str, str, pd.DataFrame]]:
+    def _get_cached(self, key: str, sdate: str = '', edate: str = '') -> Optional[Tuple[str, str, pd.DataFrame]]:
         """从缓存获取数据"""
         if self.cache:
-            cached = self.cache.get(key)
+            # 如果是 PersistentCache，使用 base_key + 日期参数的方式
+            if PersistentCache and isinstance(self.cache, PersistentCache):
+                # 从完整 key 中提取 base_key
+                parts = key.split(':')
+                if len(parts) >= 3:
+                    symbol = parts[0]
+                    freq = parts[3] if len(parts) > 3 else 'day'
+                    fq = parts[5] if len(parts) > 5 else 'qfq'
+                    base_key = f"{symbol}:{freq}:{fq}"
+                    cached = self.cache.get(base_key, sdate=sdate, edate=edate)
+                else:
+                    cached = self.cache.get(key)
+            else:
+                cached = self.cache.get(key)
             if cached:
                 return cached
         return None
@@ -95,7 +115,20 @@ class Market(ABC):
     def _put_cache(self, key: str, value: Tuple[str, str, pd.DataFrame]) -> None:
         """存入缓存"""
         if self.cache:
-            self.cache.put(key, value)
+            # 如果是 PersistentCache，使用 base_key 存储
+            if PersistentCache and isinstance(self.cache, PersistentCache):
+                # 从完整 key 中提取 base_key
+                parts = key.split(':')
+                if len(parts) >= 3:
+                    symbol = parts[0]
+                    freq = parts[3] if len(parts) > 3 else 'day'
+                    fq = parts[5] if len(parts) > 5 else 'qfq'
+                    base_key = f"{symbol}:{freq}:{fq}"
+                    self.cache.put(base_key, value)
+                else:
+                    self.cache.put(key, value)
+            else:
+                self.cache.put(key, value)
     
     def _get_price_with_persistent_cache(self, symbol: str, sdate: str, edate: str,
                                           freq: str, days: int, fq: str,
@@ -108,14 +141,18 @@ class Market(ABC):
         """
         cache_key = f"{symbol}:{sdate}:{edate}:{freq}:{days}:{fq}"
         
-        # 尝试从缓存获取
-        cached = self._get_cached(cache_key)
+        logger.info(f"[PRICE GET] symbol={symbol}, sdate={sdate}, edate={edate}, freq={freq}, cache_key={cache_key}")
+        
+        # 尝试从缓存获取（传入日期参数，PersistentCache 会使用 base_key + 日期参数）
+        cached = self._get_cached(cache_key, sdate=sdate, edate=edate)
         if cached:
             _, name, cached_df = cached
+            logger.info(f"[PRICE CACHE HIT] symbol={symbol}, 缓存数据行数={len(cached_df)}, 日期范围={cached_df.index.min() if not cached_df.empty else 'N/A'} 到 {cached_df.index.max() if not cached_df.empty else 'N/A'}")
             
             # 检查是否需要扩展
             if cached_df.empty or not isinstance(cached_df.index, pd.DatetimeIndex):
                 # 缓存为空或索引不是日期，直接获取新数据
+                logger.info(f"[PRICE FETCH] 缓存数据无效，从网络获取 symbol={symbol}, sdate={sdate}, edate={edate}")
                 result = fetch_func(symbol, sdate, edate, freq, days, fq)
                 self._put_cache(cache_key, result)
                 return result
@@ -146,11 +183,25 @@ class Market(ABC):
             
             # 如果需要扩展，获取缺失的数据
             if need_extend_forward or need_extend_backward:
+                logger.info(f"[PRICE EXTEND] 需要扩展数据, symbol={symbol}, extend_sdate={extend_sdate}, extend_edate={extend_edate}, need_forward={need_extend_forward}, need_backward={need_extend_backward}")
                 # 获取扩展的数据
                 extended_result = fetch_func(symbol, extend_sdate, extend_edate, freq, days, fq)
                 _, _, extended_df = extended_result
+                logger.info(f"[PRICE FETCH] 从网络获取扩展数据, 数据行数={len(extended_df)}")
                 
                 if not extended_df.empty:
+                    # 确保两个 DataFrame 的索引都是 DatetimeIndex
+                    if not isinstance(cached_df.index, pd.DatetimeIndex):
+                        try:
+                            cached_df.index = pd.to_datetime(cached_df.index)
+                        except (ValueError, TypeError):
+                            pass
+                    if not isinstance(extended_df.index, pd.DatetimeIndex):
+                        try:
+                            extended_df.index = pd.to_datetime(extended_df.index)
+                        except (ValueError, TypeError):
+                            pass
+                    
                     # 合并数据
                     merged_df = pd.concat([cached_df, extended_df])
                     merged_df = merged_df[~merged_df.index.duplicated(keep='last')]
@@ -172,22 +223,17 @@ class Market(ABC):
                     return result
             
             # 不需要扩展，直接返回缓存的数据
-            # 过滤到请求的日期范围
-            if request_sdate or request_edate:
-                if request_sdate and request_edate:
-                    mask = (cached_df.index >= request_sdate) & (cached_df.index <= request_edate)
-                elif request_sdate:
-                    mask = cached_df.index >= request_sdate
-                else:
-                    mask = cached_df.index <= request_edate
-                filtered_df = cached_df[mask]
-                return (symbol, name, filtered_df)
-            
+            # 注意：PersistentCache.get() 已经根据请求的日期范围进行了过滤，
+            # 返回的数据已经是过滤后的，不需要再次过滤
+            logger.info(f"[PRICE RETURN] 直接返回缓存数据, symbol={symbol}, 数据行数={len(cached_df)}")
             return (symbol, name, cached_df)
         
         # 缓存未命中，直接获取
         if fetch_func:
+            logger.info(f"[PRICE FETCH] 缓存未命中，从网络获取 symbol={symbol}, sdate={sdate}, edate={edate}")
             result = fetch_func(symbol, sdate, edate, freq, days, fq)
+            _, _, df = result
+            logger.info(f"[PRICE FETCH] 网络获取完成, 数据行数={len(df)}, 准备存储到缓存")
             self._put_cache(cache_key, result)
             return result
         else:

{rquote-0.4.0 → rquote-0.4.2}/rquote.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rquote
-Version: 0.4.0
+Version: 0.4.2
 Summary: Mostly day quotes of cn/hk/us/fund/future markets, side with quote list fetch
 Requires-Python: >=3.9.0
 Description-Content-Type: text/markdown
@@ -18,7 +18,7 @@ Requires-Dist: duckdb>=0.9.0; extra == "persistent"
 
 ## 版本信息
 
-当前版本：**0.3.5**
+当前版本：**0.4.2**
 
 ## 主要特性
 
@@ -199,13 +199,13 @@ stocks = get_cn_stock_list(money_min=5e8)
 
 #### `get_hk_stocks_500()`
 
-获取港股前500只股票列表
+获取港股前500只股票列表(按当日成交额排序)
 
 ```python
 from rquote import get_hk_stocks_500
 
 stocks = get_hk_stocks_500()
-# 返回格式: [[code, name, price, turnover, ...], ...]
+# 返回格式: [[code, name, price, -, -, -, -, volume, turnover, ...], ...]
 ```
 
 #### `get_us_stocks(k=100)`