index_data.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Tushare数据缓存系统 - 指数数据模块

这个模块提供了对Tushare指数数据的缓存和访问功能，支持多种指数数据的获取：
- 指数日线数据
- 指数周线数据
- 指数月线数据
- 指数基本信息
- 指数权重数据

主要特点：
1. 多线程并发处理，提高数据获取效率
2. 智能缓存机制，减少API调用次数
3. 完整的错误处理和日志记录
4. 支持数据更新和增量获取
"""

import pandas as pd
import logging
from concurrent.futures import ThreadPoolExecutor, as_completed
from typing import Dict, List, Optional, Union, Any
import os
import sys

# 添加项目根目录到Python路径，确保模块可以被正确导入
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

# 设置环境变量，确保Python使用UTF-8编码处理所有I/O
os.environ['PYTHONIOENCODING'] = 'utf-8'

# 导入共享日志系统
from tushare_cache_system.shared_logger import get_logger, safe_emoji_print

# 导入工具类
from tushare_cache_system.utils import UtilsMixin as TushareUtils


class IndexDataMixin:
    """
    指数数据混入类，提供指数数据相关的功能
    """
    
    def __init__(self, *args, **kwargs):
        """
        初始化指数数据混入类
        
        Args:
            *args: 位置参数
            **kwargs: 关键字参数
        """
        super().__init__(*args, **kwargs)
        self.logger = get_logger(__name__)
        self.utils = TushareUtils()
        
        # 确保指数数据目录存在
        self.index_data_dir = os.path.join(str(self.data_root), 'index_data')
        os.makedirs(self.index_data_dir, exist_ok=True)
    
    def index_daily(self, ts_code='', start_date='', end_date='', fields='', **kwargs):
        """
        获取指数日线数据（与Tushare API接口一致）
        
        Args:
            ts_code: 指数代码 (如 '000001.SH')
            start_date: 开始日期 (格式: YYYYMMDD)
            end_date: 结束日期 (格式: YYYYMMDD)
            fields: 字段列表 (逗号分隔的字符串)
            **kwargs: 其他参数
            
        Returns:
            pandas.DataFrame: 指数日线数据
        """
        self.logger.info(safe_emoji_print(f"✅ Tushare API已初始化，正在获取指数日线数据... [指数代码: {ts_code}, 开始日期: {start_date}, 结束日期: {end_date}]"))        
        if not self.pro:
            self.logger.error(safe_emoji_print("❌ Tushare API未初始化"))
            return pd.DataFrame()
            
        try:
            # 等待API可用
            if hasattr(self, 'rate_limiter'):
                self.rate_limiter.wait_for_available()
            
            # 调用Tushare API获取指数日线数据
            df = self.pro.index_daily(ts_code=ts_code, start_date=start_date, end_date=end_date)
            
            # 记录API调用
            if hasattr(self, 'rate_limiter'):
                self.rate_limiter.record_call()
            
            if df is None or df.empty:
                self.logger.warning(safe_emoji_print(f"❌ Tushare API返回空数据: index_daily [指数代码: {ts_code}, 开始日期: {start_date}, 结束日期: {end_date}]"))
                return pd.DataFrame()                
            self.logger.info(safe_emoji_print(f"✅ 成功获取指数日线数据: {len(df)} 条记录"))
            return df
            
        except Exception as e:
            self.logger.error(safe_emoji_print(f"❌ 获取指数日线数据失败: {str(e)} [指数代码: {ts_code}, 开始日期: {start_date}, 结束日期: {end_date}]"))
            return pd.DataFrame()
    
    def index_weekly(self, ts_code='', start_date='', end_date='', fields='', **kwargs):
        """
        获取指数周线数据（与Tushare API接口一致）
        
        Args:
            ts_code: 指数代码 (如 '000001.SH')
            start_date: 开始日期 (格式: YYYYMMDD)
            end_date: 结束日期 (格式: YYYYMMDD)
            fields: 字段列表 (逗号分隔的字符串)
            **kwargs: 其他参数
            
        Returns:
            pandas.DataFrame: 指数周线数据
        """
        self.logger.info(safe_emoji_print(f"✅ Tushare API已初始化，正在获取指数周线数据... [指数代码: {ts_code}, 开始日期: {start_date}, 结束日期: {end_date}]"))        
        if not self.pro:
            self.logger.error(safe_emoji_print("❌ Tushare API未初始化"))
            return pd.DataFrame()
            
        try:
            # 等待API可用
            if hasattr(self, 'rate_limiter'):
                self.rate_limiter.wait_for_available()
            
            # 调用Tushare API获取指数周线数据
            df = self.pro.index_weekly(ts_code=ts_code, start_date=start_date, end_date=end_date)
            
            # 记录API调用
            if hasattr(self, 'rate_limiter'):
                self.rate_limiter.record_call()
            
            if df is None or df.empty:
                self.logger.warning(safe_emoji_print(f"❌ Tushare API返回空数据: index_weekly [指数代码: {ts_code}, 开始日期: {start_date}, 结束日期: {end_date}]"))
                return pd.DataFrame()
                
            self.logger.info(safe_emoji_print(f"✅ 成功获取指数周线数据: {len(df)} 条记录"))
            return df
            
        except Exception as e:
            self.logger.error(safe_emoji_print(f"❌ 获取指数周线数据失败: {str(e)} [指数代码: {ts_code}, 开始日期: {start_date}, 结束日期: {end_date}]"))
            return pd.DataFrame()
    
    def index_monthly(self, ts_code='', start_date='', end_date='', fields='', **kwargs):
        """
        获取指数月线数据（与Tushare API接口一致）
        
        Args:
            ts_code: 指数代码 (如 '000001.SH')
            start_date: 开始日期 (格式: YYYYMMDD)
            end_date: 结束日期 (格式: YYYYMMDD)
            fields: 字段列表 (逗号分隔的字符串)
            **kwargs: 其他参数
            
        Returns:
            pandas.DataFrame: 指数月线数据
        """
        self.logger.info(safe_emoji_print(f"✅ Tushare API已初始化，正在获取指数月线数据... [指数代码: {ts_code}, 开始日期: {start_date}, 结束日期: {end_date}]"))
        
        if not self.pro:
            self.logger.error(safe_emoji_print("❌ Tushare API未初始化"))
            return pd.DataFrame()
            
        try:
            # 等待API可用
            if hasattr(self, 'rate_limiter'):
                self.rate_limiter.wait_for_available()
            
            # 调用Tushare API获取指数月线数据
            df = self.pro.index_monthly(ts_code=ts_code, start_date=start_date, end_date=end_date)
            
            # 记录API调用
            if hasattr(self, 'rate_limiter'):
                self.rate_limiter.record_call()
            
            if df is None or df.empty:
                self.logger.warning(safe_emoji_print(f"❌ Tushare API返回空数据: index_monthly [指数代码: {ts_code}, 开始日期: {start_date}, 结束日期: {end_date}]"))
                return pd.DataFrame()
                
            self.logger.info(safe_emoji_print(f"✅ 成功获取指数月线数据: {len(df)} 条记录"))
            return df
            
        except Exception as e:
            self.logger.error(safe_emoji_print(f"❌ 获取指数月线数据失败: {str(e)} [指数代码: {ts_code}, 开始日期: {start_date}, 结束日期: {end_date}]"))
            return pd.DataFrame()
    
    def index_basic(self, market='', fields='', **kwargs):
        """
        获取指数基本信息（与Tushare API接口一致）
        
        Args:
            market: 市场代码 (如 'MSCI', 'CSI', 'SSE', 'SZSE', 'CICC', 'SW', 'OTH')
            fields: 字段列表 (逗号分隔的字符串)
            **kwargs: 其他参数
            
        Returns:
            pandas.DataFrame: 指数基本信息
        """
        self.logger.info(safe_emoji_print(f"✅ Tushare API已初始化，正在获取指数基本信息... [市场代码: {market}]"))
        
        if not self.pro:
            self.logger.error(safe_emoji_print("❌ Tushare API未初始化"))
            return pd.DataFrame()
            
        try:
            # 等待API可用
            if hasattr(self, 'rate_limiter'):
                self.rate_limiter.wait_for_available()
            
            # 调用Tushare API获取指数基本信息
            df = self.pro.index_basic(market=market)
            
            # 记录API调用
            if hasattr(self, 'rate_limiter'):
                self.rate_limiter.record_call()
            
            if df is None or df.empty:
                self.logger.warning(safe_emoji_print(f"❌ Tushare API返回空数据: index_basic [市场代码: {market}]"))
                return pd.DataFrame()
                
            self.logger.info(safe_emoji_print(f"✅ 成功获取指数基本信息: {len(df)} 条记录"))
            return df
            
        except Exception as e:
            self.logger.error(safe_emoji_print(f"❌ 获取指数基本信息失败: {str(e)} [市场代码: {market}]"))
            return pd.DataFrame()
    
    def index_weight(self, index_code='', start_date='', end_date='', fields='', **kwargs):
        """
        获取指数权重数据（与Tushare API接口一致，带本地缓存）
        
        Args:
            index_code: 指数代码 (如 '000001.SH')
            start_date: 开始日期 (格式: YYYYMMDD)
            end_date: 结束日期 (格式: YYYYMMDD)
            fields: 字段列表 (逗号分隔的字符串)
            **kwargs: 其他参数
            
        Returns:
            pandas.DataFrame: 指数权重数据
        """
        self.logger.info(safe_emoji_print(f"✅ Tushare API已初始化，正在获取指数权重数据... [指数代码: {index_code}, 开始日期: {start_date}, 结束日期: {end_date}]"))
        
        # 生成缓存键
        cache_key = f"index_weight_{index_code}_{start_date}_{end_date}"
        
        # 尝试从缓存获取
        cached_data = self._get_from_cache(cache_key)
        if cached_data is not None:
            self.logger.info(safe_emoji_print(f"✅ 从缓存获取指数权重数据: {len(cached_data)} 条记录"))
            return cached_data
        
        if not self.pro:
            self.logger.error(safe_emoji_print("❌ Tushare API未初始化"))
            return pd.DataFrame()
            
        try:
            # 等待API可用
            if hasattr(self, 'rate_limiter'):
                self.rate_limiter.wait_for_available()
            
            # 调用Tushare API获取指数权重数据
            df = self.pro.index_weight(index_code=index_code, start_date=start_date, end_date=end_date)
            
            # 记录API调用
            if hasattr(self, 'rate_limiter'):
                self.rate_limiter.record_call()
            
            if df is None or df.empty:
                self.logger.warning(safe_emoji_print(f"❌ Tushare API返回空数据: index_weight [指数代码: {index_code}, 开始日期: {start_date}, 结束日期: {end_date}]"))
                return pd.DataFrame()
                
            self.logger.info(safe_emoji_print(f"✅ 成功获取指数权重数据: {len(df)} 条记录"))
            
            # 保存到缓存
            self._save_to_cache(cache_key, df)
            
            return df
            
        except Exception as e:
            self.logger.error(safe_emoji_print(f"❌ 获取指数权重数据失败: {str(e)} [指数代码: {index_code}, 开始日期: {start_date}, 结束日期: {end_date}]"))
            return pd.DataFrame()
    
    def index_daily(self, ts_code='', start_date='', end_date=''):
        """
        获取指数日线数据（与Tushare API接口一致，带本地缓存）
        
        Args:
            ts_code: 指数代码 (如 '000001.SH')
            start_date: 开始日期 (格式: YYYYMMDD)
            end_date: 结束日期 (格式: YYYYMMDD)
            
        Returns:
            pandas.DataFrame: 指数日线数据
        """
        self.logger.info(safe_emoji_print(f"✅ Tushare API已初始化，正在获取指数日线数据... [指数代码: {ts_code}, 开始日期: {start_date}, 结束日期: {end_date}]"))
        
        # 生成缓存键
        cache_key = f"index_daily_{ts_code}_{start_date}_{end_date}"
        
        # 尝试从缓存获取
        cached_data = self._get_from_cache(cache_key)
        if cached_data is not None:
            self.logger.info(safe_emoji_print(f"✅ 从缓存获取指数日线数据: {len(cached_data)} 条记录"))
            return cached_data
        
        if not self.pro:
            self.logger.error(safe_emoji_print("❌ Tushare API未初始化"))
            return pd.DataFrame()
            
        try:
            # 等待API可用
            if hasattr(self, 'rate_limiter'):
                self.rate_limiter.wait_for_available()
            
            # 调用Tushare API获取指数日线数据
            df = self.pro.index_daily(ts_code=ts_code, start_date=start_date, end_date=end_date)
            
            # 记录API调用
            if hasattr(self, 'rate_limiter'):
                self.rate_limiter.record_call()
            
            if df is None or df.empty:
                self.logger.warning(safe_emoji_print(f"❌ Tushare API返回空数据: index_daily [指数代码: {ts_code}, 开始日期: {start_date}, 结束日期: {end_date}]"))
                return pd.DataFrame()                
            self.logger.info(safe_emoji_print(f"✅ 成功获取指数日线数据: {len(df)} 条记录"))
            
            # 保存到缓存
            self._save_to_cache(cache_key, df)
            
            return df
            
        except Exception as e:
            self.logger.error(safe_emoji_print(f"❌ 获取指数日线数据失败: {str(e)} [指数代码: {ts_code}, 开始日期: {start_date}, 结束日期: {end_date}]"))
            return pd.DataFrame()
    
    def index_weekly(self, ts_code='', start_date='', end_date=''):
        """
        获取指数周线数据（与Tushare API接口一致，带本地缓存）
        
        Args:
            ts_code: 指数代码 (如 '000001.SH')
            start_date: 开始日期 (格式: YYYYMMDD)
            end_date: 结束日期 (格式: YYYYMMDD)
            
        Returns:
            pandas.DataFrame: 指数周线数据
        """
        self.logger.info(safe_emoji_print(f"✅ Tushare API已初始化，正在获取指数周线数据... [指数代码: {ts_code}, 开始日期: {start_date}, 结束日期: {end_date}]"))
        
        # 生成缓存键
        cache_key = f"index_weekly_{ts_code}_{start_date}_{end_date}"
        
        # 尝试从缓存获取
        cached_data = self._get_from_cache(cache_key)
        if cached_data is not None:
            self.logger.info(safe_emoji_print(f"✅ 从缓存获取指数周线数据: {len(cached_data)} 条记录"))
            return cached_data
        
        if not self.pro:
            self.logger.error(safe_emoji_print("❌ Tushare API未初始化"))
            return pd.DataFrame()
            
        try:
            # 等待API可用
            if hasattr(self, 'rate_limiter'):
                self.rate_limiter.wait_for_available()
            
            # 调用Tushare API获取指数周线数据
            df = self.pro.index_weekly(ts_code=ts_code, start_date=start_date, end_date=end_date)
            
            # 记录API调用
            if hasattr(self, 'rate_limiter'):
                self.rate_limiter.record_call()
            
            if df is None or df.empty:
                self.logger.warning(safe_emoji_print(f"❌ Tushare API返回空数据: index_weekly [指数代码: {ts_code}, 开始日期: {start_date}, 结束日期: {end_date}]"))
                return pd.DataFrame()
                
            self.logger.info(safe_emoji_print(f"✅ 成功获取指数周线数据: {len(df)} 条记录"))
            
            # 保存到缓存
            self._save_to_cache(cache_key, df)
            
            return df
            
        except Exception as e:
            self.logger.error(safe_emoji_print(f"❌ 获取指数周线数据失败: {str(e)} [指数代码: {ts_code}, 开始日期: {start_date}, 结束日期: {end_date}]"))
            return pd.DataFrame()
    
    def index_monthly(self, ts_code='', start_date='', end_date=''):
        """
        获取指数月线数据（与Tushare API接口一致，带本地缓存）
        
        Args:
            ts_code: 指数代码 (如 '000001.SH')
            start_date: 开始日期 (格式: YYYYMMDD)
            end_date: 结束日期 (格式: YYYYMMDD)
            
        Returns:
            pandas.DataFrame: 指数月线数据
        """
        self.logger.info(safe_emoji_print(f"✅ Tushare API已初始化，正在获取指数月线数据... [指数代码: {ts_code}, 开始日期: {start_date}, 结束日期: {end_date}]"))
        
        # 生成缓存键
        cache_key = f"index_monthly_{ts_code}_{start_date}_{end_date}"
        
        # 尝试从缓存获取
        cached_data = self._get_from_cache(cache_key)
        if cached_data is not None:
            self.logger.info(safe_emoji_print(f"✅ 从缓存获取指数月线数据: {len(cached_data)} 条记录"))
            return cached_data
        
        if not self.pro:
            self.logger.error(safe_emoji_print("❌ Tushare API未初始化"))
            return pd.DataFrame()
            
        try:
            # 等待API可用
            if hasattr(self, 'rate_limiter'):
                self.rate_limiter.wait_for_available()
            
            # 调用Tushare API获取指数月线数据
            df = self.pro.index_monthly(ts_code=ts_code, start_date=start_date, end_date=end_date)
            
            # 记录API调用
            if hasattr(self, 'rate_limiter'):
                self.rate_limiter.record_call()
            
            if df is None or df.empty:
                self.logger.warning(safe_emoji_print(f"❌ Tushare API返回空数据: index_monthly [指数代码: {ts_code}, 开始日期: {start_date}, 结束日期: {end_date}]"))
                return pd.DataFrame()
                
            self.logger.info(safe_emoji_print(f"✅ 成功获取指数月线数据: {len(df)} 条记录"))
            
            # 保存到缓存
            self._save_to_cache(cache_key, df)
            
            return df
            
        except Exception as e:
            self.logger.error(safe_emoji_print(f"❌ 获取指数月线数据失败: {str(e)} [指数代码: {ts_code}, 开始日期: {start_date}, 结束日期: {end_date}]"))
            return pd.DataFrame()
    
    def index_basic(self, market=''):
        """
        获取指数基本信息（与Tushare API接口一致，带本地缓存）
        
        Args:
            market: 市场代码 (如 'MSCI', 'CSI', 'SSE', 'SZSE', 'CICC', 'SW', 'OTH')
            
        Returns:
            pandas.DataFrame: 指数基本信息
        """
        self.logger.info(safe_emoji_print(f"✅ Tushare API已初始化，正在获取指数基本信息... [市场代码: {market}]"))
        
        # 生成缓存键
        cache_key = f"index_basic_{market}"
        
        # 尝试从缓存获取
        cached_data = self._get_from_cache(cache_key)
        if cached_data is not None:
            self.logger.info(safe_emoji_print(f"✅ 从缓存获取指数基本信息: {len(cached_data)} 条记录"))
            return cached_data
        
        if not self.pro:
            self.logger.error(safe_emoji_print("❌ Tushare API未初始化"))
            return pd.DataFrame()
            
        try:
            # 等待API可用
            if hasattr(self, 'rate_limiter'):
                self.rate_limiter.wait_for_available()
            
            # 调用Tushare API获取指数基本信息
            df = self.pro.index_basic(market=market)
            
            # 记录API调用
            if hasattr(self, 'rate_limiter'):
                self.rate_limiter.record_call()
            
            if df is None or df.empty:
                self.logger.warning(safe_emoji_print(f"❌ Tushare API返回空数据: index_basic [市场代码: {market}]"))
                return pd.DataFrame()
                
            self.logger.info(safe_emoji_print(f"✅ 成功获取指数基本信息: {len(df)} 条记录"))
            
            # 保存到缓存
            self._save_to_cache(cache_key, df)
            
            return df
            
        except Exception as e:
            self.logger.error(safe_emoji_print(f"❌ 获取指数基本信息失败: {str(e)} [市场代码: {market}]"))
            return pd.DataFrame()
    
    def index_weight(self, index_code='', start_date='', end_date='', fields='', **kwargs):
        """
        获取指数权重数据（与Tushare API接口一致，带本地缓存）
        
        Args:
            index_code: 指数代码 (如 '000001.SH')
            start_date: 开始日期 (格式: YYYYMMDD)
            end_date: 结束日期 (格式: YYYYMMDD)
            fields: 字段列表 (逗号分隔的字符串)
            **kwargs: 其他参数
            
        Returns:
            pandas.DataFrame: 指数权重数据
        """
        self.logger.info(safe_emoji_print(f"✅ Tushare API已初始化，正在获取指数权重数据... [指数代码: {index_code}, 开始日期: {start_date}, 结束日期: {end_date}]"))
        
        # 生成缓存键
        cache_key = f"index_weight_{index_code}_{start_date}_{end_date}"
        
        # 尝试从缓存获取
        cached_data = self._get_from_cache(cache_key)
        if cached_data is not None:
            self.logger.info(safe_emoji_print(f"✅ 从缓存获取指数权重数据: {len(cached_data)} 条记录"))
            return cached_data
        
        if not self.pro:
            self.logger.error(safe_emoji_print("❌ Tushare API未初始化"))
            return pd.DataFrame()
            
        try:
            # 等待API可用
            if hasattr(self, 'rate_limiter'):
                self.rate_limiter.wait_for_available()
            
            # 调用Tushare API获取指数权重数据
            df = self.pro.index_weight(index_code=index_code, start_date=start_date, end_date=end_date)
            
            # 记录API调用
            if hasattr(self, 'rate_limiter'):
                self.rate_limiter.record_call()
            
            if df is None or df.empty:
                self.logger.warning(safe_emoji_print(f"❌ Tushare API返回空数据: index_weight [指数代码: {index_code}, 开始日期: {start_date}, 结束日期: {end_date}]"))
                return pd.DataFrame()
                
            self.logger.info(safe_emoji_print(f"✅ 成功获取指数权重数据: {len(df)} 条记录"))
            
            # 保存到缓存
            self._save_to_cache(cache_key, df)
            
            return df
            
        except Exception as e:
            self.logger.error(safe_emoji_print(f"❌ 获取指数权重数据失败: {str(e)} [指数代码: {index_code}, 开始日期: {start_date}, 结束日期: {end_date}]"))
            return pd.DataFrame()
    
    def index_data_batch(self, index_codes, data_type='daily', start_date='', end_date=''):
        """
        批量获取指数数据（与Tushare API接口一致）
        
        Args:
            index_codes: 指数代码列表
            data_type: 数据类型 ('daily', 'weekly', 'monthly')
            start_date: 开始日期 (格式: YYYYMMDD)
            end_date: 结束日期 (格式: YYYYMMDD)
            
        Returns:
            dict: 指数代码到DataFrame的映射
        """
        if not isinstance(index_codes, list):
            index_codes = [index_codes]
            
        results = {}
        
        self.logger.info(safe_emoji_print(f"🔄 开始批量获取 {len(index_codes)} 个指数的{data_type}数据..."))
        
        for code in index_codes:
            if data_type == 'daily':
                results[code] = self.index_daily(ts_code=code, start_date=start_date, end_date=end_date)
            elif data_type == 'weekly':
                results[code] = self.index_weekly(ts_code=code, start_date=start_date, end_date=end_date)
            elif data_type == 'monthly':
                results[code] = self.index_monthly(ts_code=code, start_date=start_date, end_date=end_date)
                
        self.logger.info(safe_emoji_print(f"✅ 批量获取指数数据完成"))
        return results
        
    def sw_daily(self, ts_code='', trade_date='', start_date='', end_date='', fields='', **kwargs):
        """
        获取申万指数日线数据（与Tushare API接口一致，带本地缓存）
        
        Args:
            ts_code: 申万指数代码 (如 '801010.SI')
            trade_date: 交易日期 (格式: YYYYMMDD)
            start_date: 开始日期 (格式: YYYYMMDD)
            end_date: 结束日期 (格式: YYYYMMDD)
            fields: 字段列表 (逗号分隔的字符串)
            **kwargs: 其他参数
            
        Returns:
            pandas.DataFrame: 申万指数日线数据
        """
        # 直接调用Tushare API的sw_daily方法，支持trade_date参数
        if not self.pro:
            self.logger.error(safe_emoji_print("❌ Tushare API未初始化"))
            return pd.DataFrame()
            
        try:
            # 等待API可用
            if hasattr(self, 'rate_limiter'):
                self.rate_limiter.wait_for_available()
            
            # 调用Tushare API获取申万指数日线数据
            df = self.pro.sw_daily(ts_code=ts_code, trade_date=trade_date, start_date=start_date, end_date=end_date, fields=fields)
            
            # 记录API调用
            if hasattr(self, 'rate_limiter'):
                self.rate_limiter.record_call()
            
            if df is None or df.empty:
                self.logger.warning(safe_emoji_print(f"❌ Tushare API返回空数据: sw_daily [指数代码: {ts_code}, 交易日期: {trade_date}, 开始日期: {start_date}, 结束日期: {end_date}]"))
                return pd.DataFrame()
                
            self.logger.info(safe_emoji_print(f"✅ 成功获取申万指数日线数据: {len(df)} 条记录"))
            return df
            
        except Exception as e:
            self.logger.error(safe_emoji_print(f"❌ 获取申万指数日线数据失败: {str(e)} [指数代码: {ts_code}, 交易日期: {trade_date}, 开始日期: {start_date}, 结束日期: {end_date}]"))
            return pd.DataFrame()
    
    def index_classify(self, index_type='', level='', src='', **kwargs):
        """
        获取指数分类信息（与Tushare API接口一致，带本地缓存）
        
        Args:
            index_type: 指数类型 (如 'SW', 'CSI', 'MSCI', 'SSE', 'SZSE', 'CICC', 'OTH')
            level: 行业分级（L1/L2/L3）
            src: 指数来源 (如 'SW2021', 'SW2014', 'SW2020', 'CSICODE', 'SSECODE', 'SZSECODE')
            **kwargs: 其他参数
            
        Returns:
            pandas.DataFrame: 指数分类信息
        """
        self.logger.info(safe_emoji_print(f"✅ Tushare API已初始化，正在获取指数分类信息... [指数类型: {index_type}, 行业分级: {level}, 指数来源: {src}]"))
        
        # 生成缓存键
        cache_key = f"index_classify_{index_type}_{level}_{src}"
        
        # 尝试从缓存获取
        cached_data = self._get_from_cache(cache_key)
        if cached_data is not None:
            self.logger.info(safe_emoji_print(f"✅ 从缓存获取指数分类信息: {len(cached_data)} 条记录"))
            return cached_data
        
        if not self.pro:
            self.logger.error(safe_emoji_print("❌ Tushare API未初始化"))
            return pd.DataFrame()
            
        try:
            # 等待API可用
            if hasattr(self, 'rate_limiter'):
                self.rate_limiter.wait_for_available()
            
            # 调用Tushare API获取指数分类信息
            # 传递所有参数以保持与Tushare API的一致性
            df = self.pro.index_classify(index_type=index_type, level=level, src=src)
            
            # 记录API调用
            if hasattr(self, 'rate_limiter'):
                self.rate_limiter.record_call()
            
            if df is None or df.empty:
                self.logger.warning(safe_emoji_print(f"❌ Tushare API返回空数据: index_classify [指数类型: {index_type}, 行业分级: {level}, 指数来源: {src}]"))
                return pd.DataFrame()
                
            self.logger.info(safe_emoji_print(f"✅ 成功获取指数分类信息: {len(df)} 条记录"))
            
            # 保存到缓存
            self._save_to_cache(cache_key, df)
            
            return df
            
        except Exception as e:
            self.logger.error(safe_emoji_print(f"❌ 获取指数分类信息失败: {str(e)} [指数类型: {index_type}, 行业分级: {level}, 指数来源: {src}]"))
            return pd.DataFrame()
    
    def index_member_all(self, ts_code='', trade_date='', **kwargs):
        """
        获取指数成分股信息（与Tushare API接口一致，带本地缓存）
        
        Args:
            ts_code: 指数代码 (如 '000001.SH')
            trade_date: 交易日期 (格式: YYYYMMDD)
            **kwargs: 其他参数
            
        Returns:
            pandas.DataFrame: 指数成分股信息
        """
        # 修复回测问题：不使用当前日期作为备用值，而是返回空数据
        if trade_date is None or trade_date == '':
            self.logger.warning(safe_emoji_print("⚠️  未指定trade_date参数，在回测场景中不应使用当前日期作为备用值"))
            return pd.DataFrame()
        
        self.logger.info(safe_emoji_print(f"✅ Tushare API已初始化，正在获取指数成分股信息... [指数代码: {ts_code or 'INVALID'}, 交易日期: {trade_date}]"))
        
        # 生成缓存键
        # 将所有参数都包含在缓存键中，确保不同的参数组合使用不同的缓存
        params_str = f"ts_code={ts_code}_trade_date={trade_date}"
        for k, v in kwargs.items():
            params_str += f"_{k}={v}"
        cache_key = f"index_member_all_{params_str}"
        
        # 尝试从缓存获取
        cached_data = self._get_from_cache(cache_key)
        if cached_data is not None:
            self.logger.info(safe_emoji_print(f"✅ 从缓存获取指数成分股信息: {len(cached_data)} 条记录"))
            return cached_data
        
        if not self.pro:
            self.logger.error(safe_emoji_print("❌ Tushare API未初始化"))
            return pd.DataFrame()
            
        try:
            # 等待API可用
            if hasattr(self, 'rate_limiter'):
                self.rate_limiter.wait_for_available()
            
            # 调用Tushare API获取指数成分股信息
            # 将所有参数都传递给API
            api_params = {'ts_code': ts_code, 'trade_date': trade_date}
            api_params.update(kwargs)
            self.logger.info(safe_emoji_print(f"正在调用Tushare API: index_member_all [ts_code: {ts_code or 'None'}, trade_date: {trade_date}]"))
            df = self.pro.index_member_all(**api_params)
            
            # 记录API调用
            if hasattr(self, 'rate_limiter'):
                self.rate_limiter.record_call()
            
            if df is None or df.empty:
                self.logger.warning(safe_emoji_print(f"❌ Tushare API返回空数据: index_member_all [指数代码: {ts_code}, 交易日期: {trade_date}]"))
                return pd.DataFrame()
                
            self.logger.info(safe_emoji_print(f"✅ 成功获取指数成分股信息: {len(df)} 条记录"))
            
            # 保存到缓存
            self._save_to_cache(cache_key, df)
            
            return df
            
        except Exception as e:
            self.logger.error(safe_emoji_print(f"❌ 获取指数成分股信息失败: {str(e)} [指数代码: {ts_code}, 交易日期: {trade_date}]"))
            return pd.DataFrame()