rquote 0.4.4__py3-none-any.whl → 0.4.7__py3-none-any.whl

rquote/__init__.py

@@ -23,7 +23,8 @@ from .api import (
     get_us_stocks,
     get_cn_fund_list,
     get_tick,
-    get_industry_stocks
+    get_industry_stocks,
+    get_cnindex_stocks
 )
 
 # 工具类
@@ -89,6 +90,7 @@ __all__ = [
     'get_cn_fund_list',
     'get_tick',
     'get_industry_stocks',
+    'get_cnindex_stocks',
     # 工具类
     'WebUtils',
     'BasicFactors',

rquote/api/__init__.py

@@ -10,7 +10,8 @@ from .lists import (
     get_cn_fund_list,
     get_cn_future_list,
     get_all_industries,
-    get_industry_stocks
+    get_industry_stocks,
+    get_cnindex_stocks
 )
 from .tick import get_tick
 from .stock_info import get_stock_concepts, get_stock_industry
@@ -27,6 +28,7 @@ __all__ = [
     'get_stock_concepts',
     'get_stock_industry',
     'get_all_industries',
-    'get_industry_stocks'
+    'get_industry_stocks',
+    'get_cnindex_stocks'
 ]
 

rquote/api/lists.py

@@ -6,6 +6,7 @@ import json
 import re
 import base64
 import time
+from urllib.parse import urlencode
 from ..utils import hget, logger
 from ..exceptions import HTTPError
 
@@ -78,7 +79,7 @@ def get_us_stocks(k=100):
 
 def get_cn_fund_list():
     """
-    获取A股ETF基金列表
+    获取A股ETF基金列表（sina）
     
     Returns:
         基金列表，格式: [code, name, change, amount, price]
@@ -173,3 +174,66 @@ def get_industry_stocks(node):
     data = json.loads(a.text)
     return data
 
+
+def get_cnindex_stocks(index_type='hs300'):
+    """
+    获取中国指数成分股列表
+    
+    Args:
+        index_type: 指数类型，可选值: 'hs300', 'zz500', 'zz1000'
+                    hs300: 沪深300 (TYPE=1)
+                    zz500: 中证500 (TYPE=3)
+                    zz1000: 中证1000 (TYPE=7)
+    
+    Returns:
+        股票列表，包含 SECUCODE, SECURITY_CODE, SECURITY_NAME_ABBR, CLOSE_PRICE 等字段
+    """
+    # 指数类型到 TYPE 值的映射
+    index_type_map = {
+        'hs300': '1',
+        'zz500': '3',
+        'zz1000': '7'
+    }
+    
+    if index_type not in index_type_map:
+        raise ValueError(f"不支持的指数类型: {index_type}，支持的类型: {list(index_type_map.keys())}")
+    
+    type_value = index_type_map[index_type]
+    
+    # 构建 URL
+    base_url = 'https://datacenter-web.eastmoney.com/api/data/v1/get'
+    params = {
+        'callback': 'jQuery112308471143523381743_1763517709888',
+        'sortColumns': 'SECURITY_CODE',
+        'sortTypes': '-1',
+        'pageSize': '500',
+        'pageNumber': '1',
+        'reportName': 'RPT_INDEX_TS_COMPONENT',
+        'columns': 'SECURITY_CODE,SECURITY_NAME_ABBR,INDUSTRY,WEIGHT,EPS,BPS,ROE,FREE_CAP',
+        'quoteColumns': '',
+        'quoteType': '0',
+        'source': 'WEB',
+        'client': 'WEB',
+        'filter': f'(TYPE="{type_value}")'
+    }
+    
+    # 构建完整 URL
+    url = f'{base_url}?{urlencode(params)}'
+    
+    # 发送请求
+    a = hget(url)
+    if not a:
+        raise HTTPError(f'Failed to fetch {index_type} stocks from EastMoney')
+    
+    # 解析 JSONP 格式的返回数据
+    # 格式: jQuery112308471143523381743_1763517709888({...})
+    json_str = a.text.split('(', 1)[1].rstrip(');')
+    data = json.loads(json_str)
+    
+    # 返回 result.data 中的数据列表
+    if data.get('result') and data['result'].get('data'):
+        return data['result']['data']
+    else:
+        logger.warning(f'No data found in response for {index_type}')
+        return []
+

rquote/config.py

@@ -30,6 +30,8 @@ class Config:
         return cls(
             http_timeout=int(os.getenv('RQUOTE_HTTP_TIMEOUT', '10')),
             http_retry_times=int(os.getenv('RQUOTE_RETRY_TIMES', '3')),
+            http_retry_delay=float(os.getenv('RQUOTE_HTTP_RETRY_DELAY', '1.0')),
+            http_pool_size=int(os.getenv('RQUOTE_HTTP_POOL_SIZE', '10')),
             cache_enabled=os.getenv('RQUOTE_CACHE_ENABLED', 'true').lower() == 'true',
             cache_ttl=int(os.getenv('RQUOTE_CACHE_TTL', '3600')),
             log_level=os.getenv('RQUOTE_LOG_LEVEL', 'INFO'),

rquote/markets/base.py

@@ -98,10 +98,15 @@ class Market(ABC):
             if PersistentCache and isinstance(self.cache, PersistentCache):
                 # 从完整 key 中提取 base_key
                 parts = key.split(':')
-                if len(parts) >= 3:
+                if len(parts) == 3:
+                    # 已经是 base_key 格式：symbol:freq:fq
+                    base_key = key
+                    cached = self.cache.get(base_key, sdate=sdate, edate=edate)
+                elif len(parts) >= 6:
+                    # 完整 key 格式：symbol:sdate:edate:freq:days:fq
                     symbol = parts[0]
-                    freq = parts[3] if len(parts) > 3 else 'day'
-                    fq = parts[5] if len(parts) > 5 else 'qfq'
+                    freq = parts[3]
+                    fq = parts[5]
                     base_key = f"{symbol}:{freq}:{fq}"
                     cached = self.cache.get(base_key, sdate=sdate, edate=edate)
                 else:
@@ -119,10 +124,15 @@ class Market(ABC):
             if PersistentCache and isinstance(self.cache, PersistentCache):
                 # 从完整 key 中提取 base_key
                 parts = key.split(':')
-                if len(parts) >= 3:
+                if len(parts) == 3:
+                    # 已经是 base_key 格式：symbol:freq:fq
+                    base_key = key
+                    self.cache.put(base_key, value)
+                elif len(parts) >= 6:
+                    # 完整 key 格式：symbol:sdate:edate:freq:days:fq
                     symbol = parts[0]
-                    freq = parts[3] if len(parts) > 3 else 'day'
-                    fq = parts[5] if len(parts) > 5 else 'qfq'
+                    freq = parts[3]
+                    fq = parts[5]
                     base_key = f"{symbol}:{freq}:{fq}"
                     self.cache.put(base_key, value)
                 else:
@@ -164,63 +174,124 @@ class Market(ABC):
             
             need_extend_forward = False  # 需要向前扩展（更新日期）
             need_extend_backward = False  # 需要向后扩展（更早日期）
+            need_extend_for_length = False  # 需要扩展以满足长度要求（>=60行）
             extend_sdate = sdate
             extend_edate = edate
             
-            # 检查是否需要向前扩展
+            # 逻辑1: 检查是否需要向前扩展（请求的 edate 晚于缓存的最新日期）
             if request_edate and request_edate > cached_latest:
                 need_extend_forward = True
                 # 从缓存的最新日期+1天开始，扩展到请求的 edate
                 extend_sdate = (cached_latest + pd.Timedelta(days=1)).strftime('%Y-%m-%d')
                 extend_edate = edate
             
-            # 检查是否需要向后扩展
-            if request_sdate and request_sdate < cached_earliest:
+            # 逻辑2: 如果从cache取的数据在edate前的长度小于等于60，则进行网络请求取数合并进cache
+            elif request_edate:
+                # 计算edate之前的数据行数
+                data_before_edate = cached_df[cached_df.index <= request_edate]
+                if len(data_before_edate) <= 60:
+                    need_extend_for_length = True
+                    # 从更早的日期开始获取，确保edate前有足够的数据（>=60行）
+                    # 往前推约4个月（120天），确保有足够的交易日
+                    target_sdate = request_edate - pd.Timedelta(days=120)
+                    extend_sdate = target_sdate.strftime('%Y-%m-%d')
+                    extend_edate = edate
+                    logger.info(f"[PRICE EXTEND LENGTH] symbol={symbol}, edate前数据行数={len(data_before_edate)} <= 60, 从更早日期获取, extend_sdate={extend_sdate}")
+            
+            # 逻辑3: 如果cache中有数据，但新的edate小于cache中数据最小值
+            elif request_edate and request_edate < cached_earliest:
+                need_extend_backward = True
+                # 从缓存最早日期开始往前获取，直到覆盖edate且edate前的长度大于60
+                # 先尝试从edate往前推足够的天数（约4个月）
+                target_sdate = request_edate - pd.Timedelta(days=120)
+                extend_sdate = target_sdate.strftime('%Y-%m-%d')
+                extend_edate = (cached_earliest - pd.Timedelta(days=1)).strftime('%Y-%m-%d')
+                logger.info(f"[PRICE EXTEND EARLY] symbol={symbol}, edate={request_edate} 早于缓存最早日期={cached_earliest}, 从更早日期获取, extend_sdate={extend_sdate}, extend_edate={extend_edate}")
+            
+            # 检查是否需要向后扩展（请求的 sdate 早于缓存的最早日期，且不是情况3）
+            if request_sdate and request_sdate < cached_earliest and not need_extend_backward:
                 need_extend_backward = True
                 # 从请求的 sdate 开始，扩展到缓存的最早日期-1天
                 extend_sdate = sdate
                 extend_edate = (cached_earliest - pd.Timedelta(days=1)).strftime('%Y-%m-%d')
             
             # 如果需要扩展，获取缺失的数据
-            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 need_extend_forward or need_extend_backward or need_extend_for_length:
+                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}, need_length={need_extend_for_length}")
                 
-                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')]
-                    merged_df = merged_df.sort_index()
-                    
-                    # 过滤到请求的日期范围
-                    if request_sdate or request_edate:
-                        if request_sdate and request_edate:
-                            mask = (merged_df.index >= request_sdate) & (merged_df.index <= request_edate)
-                        elif request_sdate:
-                            mask = merged_df.index >= request_sdate
-                        else:
-                            mask = merged_df.index <= request_edate
-                        merged_df = merged_df[mask]
+                # 对于逻辑2和逻辑3，可能需要循环获取直到满足条件
+                max_iterations = 5  # 最多循环5次，避免无限循环
+                iteration = 0
+                current_merged_df = cached_df.copy()
+                
+                while iteration < max_iterations:
+                    iteration += 1
+                    # 获取扩展的数据
+                    extended_result = fetch_func(symbol, extend_sdate, extend_edate, freq, days, fq)
+                    _, _, extended_df = extended_result
+                    logger.info(f"[PRICE FETCH] 从网络获取扩展数据 (迭代{iteration}), 数据行数={len(extended_df)}")
                     
-                    result = (symbol, name, merged_df)
-                    # 更新缓存（使用原始 key，PersistentCache 会智能合并）
-                    self._put_cache(cache_key, result)
-                    return result
+                    if not extended_df.empty:
+                        # 确保两个 DataFrame 的索引都是 DatetimeIndex
+                        if not isinstance(current_merged_df.index, pd.DatetimeIndex):
+                            try:
+                                current_merged_df.index = pd.to_datetime(current_merged_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
+                        
+                        # 合并数据
+                        current_merged_df = pd.concat([current_merged_df, extended_df])
+                        current_merged_df = current_merged_df[~current_merged_df.index.duplicated(keep='last')]
+                        current_merged_df = current_merged_df.sort_index()
+                        
+                        # 检查是否满足条件（逻辑2和逻辑3需要检查长度）
+                        if need_extend_for_length or need_extend_backward:
+                            if request_edate:
+                                data_before_edate = current_merged_df[current_merged_df.index <= request_edate]
+                                if len(data_before_edate) > 60:
+                                    # 满足条件，退出循环
+                                    logger.info(f"[PRICE EXTEND] 已满足长度要求, edate前数据行数={len(data_before_edate)}")
+                                    break
+                                else:
+                                    # 还需要继续获取更早的数据
+                                    current_earliest = current_merged_df.index.min()
+                                    if current_earliest <= pd.to_datetime(extend_sdate):
+                                        # 已经获取到最早的数据，无法再往前获取
+                                        logger.warning(f"[PRICE EXTEND] 已获取到最早数据，但edate前数据行数={len(data_before_edate)}仍不足60行")
+                                        break
+                                    # 继续往前推
+                                    extend_sdate_dt = pd.to_datetime(extend_sdate) - pd.Timedelta(days=120)
+                                    extend_sdate = extend_sdate_dt.strftime('%Y-%m-%d')
+                                    logger.info(f"[PRICE EXTEND] 继续获取更早数据, 新extend_sdate={extend_sdate}")
+                                    continue
+                        
+                        # 对于逻辑1（向前扩展），不需要循环，直接退出
+                        if need_extend_forward and not need_extend_for_length and not need_extend_backward:
+                            break
+                    else:
+                        # 获取失败，退出循环
+                        logger.warning(f"[PRICE EXTEND] 获取数据为空，退出循环")
+                        break
+                
+                # 过滤到请求的日期范围
+                if request_sdate or request_edate:
+                    if request_sdate and request_edate:
+                        mask = (current_merged_df.index >= request_sdate) & (current_merged_df.index <= request_edate)
+                    elif request_sdate:
+                        mask = current_merged_df.index >= request_sdate
+                    else:
+                        mask = current_merged_df.index <= request_edate
+                    current_merged_df = current_merged_df[mask]
+                
+                result = (symbol, name, current_merged_df)
+                # 更新缓存（使用原始 key，PersistentCache 会智能合并）
+                self._put_cache(cache_key, result)
+                return result
             
             # 不需要扩展，直接返回缓存的数据
             # 注意：PersistentCache.get() 已经根据请求的日期范围进行了过滤，

rquote/markets/cn_stock.py

@@ -31,11 +31,10 @@ class CNStockMarket(Market):
         if symbol[:2] == 'BK':
             return self._get_bk_price(symbol)
         
-        # 特殊处理PT代码（不使用缓存）
-        if symbol[:2] == 'pt':
-            return self._get_pt_price(symbol, sdate, edate, freq, days, fq)
-        
-        # 使用基类的缓存逻辑
+        # PT代码也使用基类的缓存逻辑（包含长度检查和扩展逻辑）
+        # 使用基类的缓存逻辑，所有市场都会应用这两个逻辑：
+        # 1. 如果从cache取的数据在edate前的长度小于等于60，则进行网络请求取数合并进cache
+        # 2. 如果cache中有数据，但新的edate小于cache中数据最小值，从更早日期开始取并合并
         return super().get_price(symbol, sdate, edate, freq, days, fq)
     
     def _fetch_price_data(self, symbol: str, sdate: str = '', edate: str = '', 
@@ -94,30 +93,139 @@ class CNStockMarket(Market):
     def _get_pt_price(self, symbol: str, sdate: str, edate: str, 
                      freq: str, days: int, fq: str) -> Tuple[str, str, pd.DataFrame]:
         """获取PT代码价格"""
+        # 先检查缓存（使用base_key格式，日期通过参数传递）
+        base_key = f"{symbol}:{freq}:{fq}"
+        cached = self._get_cached(base_key, sdate=sdate, edate=edate)
+        cached_df = None
+        need_fetch = False  # 标记是否需要从网络获取数据
+        if cached:
+            _, name, cached_df = cached
+            # 检查缓存数据是否满足请求的 edate
+            if not cached_df.empty and isinstance(cached_df.index, pd.DatetimeIndex):
+                cached_earliest = cached_df.index.min()
+                cached_latest = cached_df.index.max()
+                request_edate = pd.to_datetime(edate) if edate else None
+                request_sdate = pd.to_datetime(sdate) if sdate else None
+                
+                # 逻辑1: 如果请求的 edate 晚于缓存的最新日期，需要从网络获取新数据
+                if request_edate and request_edate > cached_latest:
+                    logger.info(f"[PT CACHE INCOMPLETE] symbol={symbol}, 缓存最新日期={cached_latest}, 请求日期={request_edate}, 需要扩展数据")
+                    need_fetch = True
+                # 逻辑2: 如果从cache取的数据在edate前的长度小于等于60，则进行网络请求取数合并进cache
+                elif request_edate:
+                    # 计算edate之前的数据行数
+                    data_before_edate = cached_df[cached_df.index <= request_edate]
+                    if len(data_before_edate) <= 60:
+                        logger.info(f"[PT CACHE INSUFFICIENT] symbol={symbol}, edate前数据行数={len(data_before_edate)} <= 60, 需要获取更多历史数据")
+                        need_fetch = True
+                # 逻辑3: 如果cache中有数据，但新的edate小于cache中数据最小值，需要从更早的日期开始取
+                elif request_edate and request_edate < cached_earliest:
+                    logger.info(f"[PT CACHE EARLY] symbol={symbol}, 请求edate={request_edate} 早于缓存最早日期={cached_earliest}, 需要从更早日期获取")
+                    need_fetch = True
+                else:
+                    logger.info(f"[PT CACHE HIT] symbol={symbol}, 从缓存返回数据, 日期范围={cached_df.index.min()} 到 {cached_df.index.max()}")
+                    return cached
+            else:
+                logger.info(f"[PT CACHE HIT] symbol={symbol}, 从缓存返回数据")
+                return cached
+        
         try:
-            url = f'https://proxy.finance.qq.com/ifzqgtimg/appstock/app/newfqkline/get?_var=kline_dayqfq&param={symbol},{freq},{sdate},{edate},{days},{fq}'
+            # 确定需要获取的日期范围
+            extend_sdate = sdate
+            extend_edate = edate
+            need_multiple_fetch = False  # 是否需要多次获取以满足长度要求
+            
+            if cached and cached_df is not None and not cached_df.empty and isinstance(cached_df.index, pd.DatetimeIndex):
+                cached_earliest = cached_df.index.min()
+                cached_latest = cached_df.index.max()
+                request_edate = pd.to_datetime(edate) if edate else None
+                request_sdate = pd.to_datetime(sdate) if sdate else None
+                
+                # 情况1: 请求的 edate 晚于缓存的最新日期，从缓存的最新日期+1天开始获取
+                if request_edate and request_edate > cached_latest:
+                    extend_sdate = (cached_latest + pd.Timedelta(days=1)).strftime('%Y-%m-%d')
+                    logger.info(f"[PT FETCH] 从缓存最新日期后开始获取, extend_sdate={extend_sdate}, edate={edate}")
+                # 情况2: edate前的数据长度<=60，需要获取更多历史数据
+                elif request_edate:
+                    data_before_edate = cached_df[cached_df.index <= request_edate]
+                    if len(data_before_edate) <= 60:
+                        # 计算需要获取多少天的数据才能达到60+行
+                        # 假设每个交易日都有数据，需要大约60个交易日（约3个月）
+                        # 从edate往前推，确保获取足够的数据
+                        target_sdate = request_edate - pd.Timedelta(days=120)  # 往前推约4个月，确保有足够交易日
+                        extend_sdate = target_sdate.strftime('%Y-%m-%d')
+                        extend_edate = edate
+                        logger.info(f"[PT FETCH] edate前数据不足60行，从更早日期获取, extend_sdate={extend_sdate}, extend_edate={extend_edate}")
+                        need_multiple_fetch = True  # 可能需要多次获取
+                # 情况3: 请求的edate早于缓存的最早日期，从缓存最早日期开始往前获取
+                elif request_edate and request_edate < cached_earliest:
+                    # 从缓存最早日期开始往前获取，直到覆盖edate且edate前的长度大于60
+                    # 先尝试从edate往前推足够的天数
+                    target_sdate = request_edate - pd.Timedelta(days=120)  # 往前推约4个月
+                    extend_sdate = target_sdate.strftime('%Y-%m-%d')
+                    extend_edate = (cached_earliest - pd.Timedelta(days=1)).strftime('%Y-%m-%d')
+                    logger.info(f"[PT FETCH] edate早于缓存最早日期，从更早日期获取, extend_sdate={extend_sdate}, extend_edate={extend_edate}")
+                    need_multiple_fetch = True  # 可能需要多次获取
+            
+            url = f'https://proxy.finance.qq.com/ifzqgtimg/appstock/app/newfqkline/get?_var=kline_dayqfq&param={symbol},{freq},{extend_sdate},{extend_edate},{days},{fq}'
             response = hget(url)
             if not response:
                 logger.warning(f'{symbol} hget failed')
+                # 如果网络请求失败，但有缓存数据，返回缓存数据
+                if cached:
+                    logger.info(f"[PT FALLBACK] 网络请求失败，返回缓存数据")
+                    return cached
                 return symbol, 'None', pd.DataFrame([])
             
             response_text = response.text
             json_start = response_text.find('{')
             if json_start == -1:
                 logger.warning(f'{symbol} invalid response format')
+                # 如果解析失败，但有缓存数据，返回缓存数据
+                if cached:
+                    logger.info(f"[PT FALLBACK] 解析失败，返回缓存数据")
+                    return cached
                 return symbol, 'None', pd.DataFrame([])
             
             data = json.loads(response_text[json_start:])
             if data.get('code') != 0:
                 logger.warning(f'{symbol} API returned error: {data.get("msg", "Unknown error")}')
+                # 如果API返回错误，但有缓存数据，返回缓存数据
+                if cached:
+                    logger.info(f"[PT FALLBACK] API错误，返回缓存数据")
+                    return cached
                 return symbol, 'None', pd.DataFrame([])
             
             # 使用解析器
             try:
                 parser = KlineParser()
                 name, df = parser.parse_tencent_kline(data, symbol)
-                result = (symbol, name, df)
-                self._put_cache(f"{symbol}:{sdate}:{edate}:{freq}", result)
+                
+                # 如果有缓存数据，合并新旧数据
+                if cached and cached_df is not None and not cached_df.empty and isinstance(cached_df.index, pd.DatetimeIndex):
+                    # 确保两个 DataFrame 的索引都是 DatetimeIndex
+                    if not isinstance(df.index, pd.DatetimeIndex):
+                        try:
+                            df.index = pd.to_datetime(df.index)
+                        except (ValueError, TypeError):
+                            pass
+                    
+                    # 合并数据
+                    merged_df = pd.concat([cached_df, df])
+                    merged_df = merged_df[~merged_df.index.duplicated(keep='last')]
+                    merged_df = merged_df.sort_index()
+                    
+                    # 过滤到请求的日期范围
+                    if edate:
+                        request_edate = pd.to_datetime(edate)
+                        merged_df = merged_df[merged_df.index <= request_edate]
+                    
+                    result = (symbol, name, merged_df)
+                    logger.info(f"[PT MERGE] 合并缓存和新数据, 缓存行数={len(cached_df)}, 新数据行数={len(df)}, 合并后行数={len(merged_df)}")
+                else:
+                    result = (symbol, name, df)
+                
+                self._put_cache(base_key, result)
                 return result
             except Exception as e:
                 logger.warning(f'Failed to parse {symbol}, using fallback: {e}')
@@ -146,8 +254,31 @@ class CNStockMarket(Market):
                 for col in ['open', 'high', 'low', 'close', 'vol']:
                     df[col] = pd.to_numeric(df[col], errors='coerce')
                 
-                result = (symbol, name, df)
-                self._put_cache(f"{symbol}:{sdate}:{edate}:{freq}", result)
+                # 如果有缓存数据，合并新旧数据
+                if cached and cached_df is not None and not cached_df.empty and isinstance(cached_df.index, pd.DatetimeIndex):
+                    # 确保两个 DataFrame 的索引都是 DatetimeIndex
+                    if not isinstance(df.index, pd.DatetimeIndex):
+                        try:
+                            df.index = pd.to_datetime(df.index)
+                        except (ValueError, TypeError):
+                            pass
+                    
+                    # 合并数据
+                    merged_df = pd.concat([cached_df, df])
+                    merged_df = merged_df[~merged_df.index.duplicated(keep='last')]
+                    merged_df = merged_df.sort_index()
+                    
+                    # 过滤到请求的日期范围
+                    if edate:
+                        request_edate = pd.to_datetime(edate)
+                        merged_df = merged_df[merged_df.index <= request_edate]
+                    
+                    result = (symbol, name, merged_df)
+                    logger.info(f"[PT MERGE FALLBACK] 合并缓存和新数据, 缓存行数={len(cached_df)}, 新数据行数={len(df)}, 合并后行数={len(merged_df)}")
+                else:
+                    result = (symbol, name, df)
+                
+                self._put_cache(base_key, result)
                 return result
         except Exception as e:
             logger.warning(f'error fetching {symbol}, err: {e}')

{rquote-0.4.4.dist-info → rquote-0.4.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rquote
-Version: 0.4.4
+Version: 0.4.7
 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.4.4**
+当前版本：**0.4.7**
 
 ## 主要特性
 
@@ -219,6 +219,28 @@ us_stocks = get_us_stocks(k=100)  # 获取前100只
 # 返回格式: [{name, symbol, market, mktcap, pe, ...}, ...]
 ```
 
+#### `get_cnindex_stocks(index_type='hs300')`
+
+获取中国指数成分股列表
+
+```python
+from rquote import get_cnindex_stocks
+
+# 获取沪深300成分股
+hs300_stocks = get_cnindex_stocks('hs300')
+# 获取中证500成分股
+zz500_stocks = get_cnindex_stocks('zz500')
+# 获取中证1000成分股
+zz1000_stocks = get_cnindex_stocks('zz1000')
+
+# 返回格式: [{SECURITY_CODE, SECURITY_NAME_ABBR, INDUSTRY, WEIGHT, EPS, BPS, ROE, FREE_CAP, ...}, ...]
+```
+
+支持的指数类型：
+- `'hs300'`: 沪深300
+- `'zz500'`: 中证500
+- `'zz1000'`: 中证1000
+
 ### 基金和期货
 
 #### `get_cn_fund_list()`

{rquote-0.4.4.dist-info → rquote-0.4.7.dist-info}/RECORD

@@ -1,10 +1,10 @@
-rquote/__init__.py,sha256=HMXqZ_wfGoRqw1V3xm2MyBGYKB9ooGWIRnk60bisLZo,2370
-rquote/config.py,sha256=noep_VzY_nJehnkPQb4mkwzpeYLwkU1riqofQJ6Hhw0,1108
+rquote/__init__.py,sha256=VEZOnqv7Erc34qqllI17bG9cezoaf9uNoOtX9fmhtyw,2420
+rquote/config.py,sha256=WTdjXCT0FcxGW1ZFe4AfjyGvGQD68uzm0rr7PAN8UBQ,1263
 rquote/exceptions.py,sha256=lJH2GC5dDhMoW_OtlBc03wlUn684-7jNPyF1NjmfVIE,569
 rquote/plots.py,sha256=UQn4sjhIzVwagfhUDM738b2HHjKo4tRdU2UCs_1-FbY,2341
 rquote/utils.py,sha256=bH0ZFIo-ZelNztzPS6BXFShXE3yGA9USI_P9INN0Y-s,310
-rquote/api/__init__.py,sha256=ptizO--im80HaxlzxkJo9BKdJPEnbu00R9UDgcoA0mU,656
-rquote/api/lists.py,sha256=fRebS02Fi0qe6KpWBA-9W1UG0It6__DmRlNimtMa7L8,5331
+rquote/api/__init__.py,sha256=17VgPOKsbQX8kKcuU8fKqn4qOHxMamV9GBTXTCcbdvw,706
+rquote/api/lists.py,sha256=WGyliA9pkpPrN019xkhKL-5nzrmTGrsb8bnG8Zz4cRs,7395
 rquote/api/price.py,sha256=I5lZl6cUQRlE4AtzNbR-uGZt1ho9vgP1cgNFDjaigMA,3575
 rquote/api/stock_info.py,sha256=h_AbgsR8CLWz5zA2PtGsS3ROQ3qcw_hnRAtG3USeMos,2988
 rquote/api/tick.py,sha256=nEcjuAjtBHUaD8KPRLg643piVa21PhKDQvkVWNwvvME,1431
@@ -19,8 +19,8 @@ rquote/data_sources/tencent.py,sha256=ayt1O85pheLwzX3z5c6Qij1NrmUywcsz6YcSVzdDoM
 rquote/factors/__init__.py,sha256=_ZbH2XxYtXwCJpvRVdNvGncoPSpMqrtlYmf1_fMGIjM,116
 rquote/factors/technical.py,sha256=dPDs3pDEDRV9iQJBrSoKpGFLQMjOqyoBdN2rUntpOUU,4235
 rquote/markets/__init__.py,sha256=k4F8cZgb-phqemMqhZXFPdOKsR4P--DD3d5i21vKhbg,365
-rquote/markets/base.py,sha256=nHBMzQRkuDUrsx9GvB_QiMh2deMUjTiUZsIRYPJpB_8,11206
-rquote/markets/cn_stock.py,sha256=nu2ebTE4a6FAJkvpMN0FEPuqwom_hqTRjnUg96cQGKc,8320
+rquote/markets/base.py,sha256=Oe-taKEdDCfaFGCnALB-gunSFMhe_OD736bVv7OBGHU,16433
+rquote/markets/cn_stock.py,sha256=MQj_mNADY50Hc3IPviQi51ixMI_XKZXiuYHo6k1PXCI,17150
 rquote/markets/factory.py,sha256=4Txpuok0LBOLT_vAiIU-NslwVnYF7sKHCdlacAboxpo,2875
 rquote/markets/future.py,sha256=yGMyUu9Fv75jbzPbvW6_36otEeebSij7vnzow_zyEn8,7358
 rquote/markets/hk_stock.py,sha256=AhRJpWp027ACew9ogxkVCJXbqbYQ1AkbFwDJccXbvAs,1183
@@ -33,7 +33,7 @@ rquote/utils/helpers.py,sha256=V07n9BtRS8bEJH023Kca78-unk7iD3B9hn2UjELetYs,354
 rquote/utils/http.py,sha256=X0Alhnu0CNqyQeOt6ivUWmh2XwrWxXd2lSpQOKDdnzw,3249
 rquote/utils/logging.py,sha256=fs2YF1Srux4LLTdk_Grjm5g1f4mzewI38VVSAI82goA,1471
 rquote/utils/web.py,sha256=I8_pcThW6VUvahuRHdtp32iZwr85hEt1hB6TgznMy_U,3854
-rquote-0.4.4.dist-info/METADATA,sha256=19kwtEiSyrMll1Ju8Ei1nR4CHCohDhht02hLXsHL47k,14344
-rquote-0.4.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-rquote-0.4.4.dist-info/top_level.txt,sha256=CehAiaZx7Fo8HGoV2zd5GhILUW1jQEN8YS-cWMlrK9Y,7
-rquote-0.4.4.dist-info/RECORD,,
+rquote-0.4.7.dist-info/METADATA,sha256=Ugxawwms3YT8209UMnAaPwxZ20L2_fc2SmIlHQPV4YA,14898
+rquote-0.4.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+rquote-0.4.7.dist-info/top_level.txt,sha256=CehAiaZx7Fo8HGoV2zd5GhILUW1jQEN8YS-cWMlrK9Y,7
+rquote-0.4.7.dist-info/RECORD,,