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

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

@@ -174,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 = '', 
@@ -97,33 +96,135 @@ class CNStockMarket(Market):
         # 先检查缓存（使用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:
-            logger.info(f"[PT CACHE HIT] symbol={symbol}, 从缓存返回数据")
-            return 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)
+                
+                # 如果有缓存数据，合并新旧数据
+                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:
@@ -153,7 +254,30 @@ class CNStockMarket(Market):
                 for col in ['open', 'high', 'low', 'close', 'vol']:
                     df[col] = pd.to_numeric(df[col], errors='coerce')
                 
-                result = (symbol, name, df)
+                # 如果有缓存数据，合并新旧数据
+                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:

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rquote
-Version: 0.4.6
+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.6**
+当前版本：**0.4.7**
 
 ## 主要特性
 

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

@@ -1,5 +1,5 @@
 rquote/__init__.py,sha256=VEZOnqv7Erc34qqllI17bG9cezoaf9uNoOtX9fmhtyw,2420
-rquote/config.py,sha256=noep_VzY_nJehnkPQb4mkwzpeYLwkU1riqofQJ6Hhw0,1108
+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
@@ -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=SyzghAMvSoQNL8DbHCXbWQ0bhu0pDlJrYmO16L_blOI,11646
-rquote/markets/cn_stock.py,sha256=lATGlunbR5cV-D84S3iD-VKc3L71hz4dyYx8YBYiuQg,8596
+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.6.dist-info/METADATA,sha256=LRPiTig-kVH_yqrJpXu2h_8wlq4q9pjghHs3Fmv687w,14898
-rquote-0.4.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-rquote-0.4.6.dist-info/top_level.txt,sha256=CehAiaZx7Fo8HGoV2zd5GhILUW1jQEN8YS-cWMlrK9Y,7
-rquote-0.4.6.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,,