rquote 0.3.4__py3-none-any.whl → 0.3.5__py3-none-any.whl

rquote/data_sources/sina.py

@@ -0,0 +1,92 @@
+# -*- coding: utf-8 -*-
+"""
+新浪数据源
+"""
+import json
+from typing import Dict, Any, List
+from .base import DataSource
+from ..utils.http import HTTPClient
+from ..exceptions import DataSourceError, ParseError
+
+
+class SinaDataSource(DataSource):
+    """新浪数据源"""
+    
+    BASE_URL_FUTURE = "https://stock2.finance.sina.com.cn/futures/api/jsonp.php/"
+    BASE_URL_TICK = "https://hq.sinajs.cn/?list="
+    
+    def __init__(self, http_client: HTTPClient = None):
+        """
+        初始化新浪数据源
+        
+        Args:
+            http_client: HTTP客户端
+        """
+        self.http_client = http_client or HTTPClient()
+    
+    def fetch_kline(self, symbol: str, **kwargs) -> Dict[str, Any]:
+        """
+        从新浪获取K线数据（主要用于期货）
+        
+        Args:
+            symbol: 期货代码（不含fu前缀）
+            **kwargs: 其他参数
+        """
+        freq = kwargs.get('freq', 'day')
+        
+        if freq in ('min', '1min', 'minute'):
+            url = f"{self.BASE_URL_FUTURE}var%20t1nf_{symbol}=/InnerFuturesNewService.getMinLine?symbol={symbol}"
+        else:
+            url = f"{self.BASE_URL_FUTURE}var%20t1nf_{symbol}=/InnerFuturesNewService.getDailyKLine?symbol={symbol}"
+        
+        response = self.http_client.get(url)
+        if not response:
+            raise DataSourceError(f"Failed to fetch from Sina: {symbol}")
+        
+        try:
+            # 解析JavaScript变量赋值格式
+            text = response.text
+            # 提取JSON部分
+            json_start = text.find('[')
+            if json_start == -1:
+                json_start = text.find('{')
+            if json_start == -1:
+                raise ParseError("Invalid response format")
+            
+            data = json.loads(text[json_start:])
+            return {'data': data}
+        except json.JSONDecodeError as e:
+            raise ParseError(f"Parse error: {e}")
+    
+    def fetch_tick(self, symbols: List[str]) -> Dict[str, Any]:
+        """
+        获取实时行情
+        
+        Args:
+            symbols: 股票代码列表（美股需要gb_前缀）
+        """
+        # 美股需要gb_前缀
+        if isinstance(symbols, str):
+            symbols = [symbols]
+        
+        tick_symbols = ['gb_' + s.lower() if not s.startswith('gb_') else s for s in symbols]
+        url = f"{self.BASE_URL_TICK}{','.join(tick_symbols)}"
+        
+        response = self.http_client.get(url)
+        if not response:
+            raise DataSourceError("Failed to fetch tick data from Sina")
+        
+        try:
+            # 解析响应
+            lines = response.text.split(';\n')
+            result = []
+            for line in lines:
+                if ',' in line and '=' in line:
+                    parts = line.split('=')
+                    if len(parts) == 2:
+                        data_str = parts[1].strip('"')
+                        result.append(data_str.split(','))
+            return {'data': result}
+        except Exception as e:
+            raise ParseError(f"Parse tick error: {e}")
+

rquote/data_sources/tencent.py

@@ -0,0 +1,90 @@
+# -*- coding: utf-8 -*-
+"""
+腾讯数据源
+"""
+import json
+from typing import Dict, Any, List
+from .base import DataSource
+from ..utils.http import HTTPClient
+from ..exceptions import DataSourceError, ParseError
+
+
+class TencentDataSource(DataSource):
+    """腾讯数据源"""
+    
+    BASE_URL = "http://web.ifzq.gtimg.cn/appstock/app/newfqkline/get"
+    BASE_URL_HK = "http://web.ifzq.gtimg.cn/appstock/app/hkfqkline/get"
+    BASE_URL_US = "http://web.ifzq.gtimg.cn/appstock/app/usfqkline/get"
+    
+    def __init__(self, http_client: HTTPClient = None):
+        """
+        初始化腾讯数据源
+        
+        Args:
+            http_client: HTTP客户端，如果为None则创建新实例
+        """
+        self.http_client = http_client or HTTPClient()
+    
+    def fetch_kline(self, symbol: str, freq: str = 'day', 
+                   sdate: str = '', edate: str = '', 
+                   days: int = 320, fq: str = 'qfq') -> Dict[str, Any]:
+        """
+        从腾讯获取K线数据
+        
+        Args:
+            symbol: 股票代码
+            freq: 频率
+            sdate: 开始日期
+            edate: 结束日期
+            days: 天数
+            fq: 复权方式
+        
+        Returns:
+            数据字典
+        """
+        # 根据市场选择URL
+        if symbol[:2] in ['sh', 'sz']:
+            url = f"{self.BASE_URL}?param={symbol},{freq},{sdate},{edate},{days},{fq}"
+        elif symbol[:2] == 'hk':
+            url = f"{self.BASE_URL_HK}?param={symbol},{freq},{sdate},{edate},{days},{fq}"
+        elif symbol[:2] == 'us':
+            url = f"{self.BASE_URL_US}?param={symbol},{freq},{sdate},{edate},{days},{fq}"
+        else:
+            raise DataSourceError(f"Unsupported symbol format: {symbol}")
+        
+        response = self.http_client.get(url)
+        if not response:
+            raise DataSourceError(f"Failed to fetch from Tencent: {symbol}")
+        
+        # 解析响应
+        try:
+            text = response.text
+            # 处理不同的响应格式
+            if text.startswith('{'):
+                # 直接是JSON
+                data = json.loads(text)
+            elif '=' in text and '{' in text:
+                # JavaScript变量赋值格式: var_name={...}
+                json_start = text.find('{')
+                if json_start == -1:
+                    raise ParseError("Invalid response format")
+                data = json.loads(text[json_start:])
+            else:
+                # 尝试直接解析
+                json_start = text.find('{')
+                if json_start == -1:
+                    raise ParseError("Invalid response format")
+                data = json.loads(text[json_start:])
+            
+            # 检查API返回码
+            if isinstance(data, dict) and data.get('code') != 0:
+                raise DataSourceError(f"API error: {data.get('msg', 'Unknown error')}")
+            
+            return data
+        except json.JSONDecodeError as e:
+            raise ParseError(f"Parse error: {e}")
+    
+    def fetch_tick(self, symbols: List[str]) -> Dict[str, Any]:
+        """获取实时行情（暂未实现）"""
+        raise NotImplementedError("Tencent tick data not implemented yet")
+

rquote/exceptions.py

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+"""
+异常定义模块
+"""
+
+
+class RQuoteException(Exception):
+    """基础异常类"""
+    pass
+
+
+class DataSourceError(RQuoteException):
+    """数据源错误"""
+    pass
+
+
+class ParseError(RQuoteException):
+    """解析错误"""
+    pass
+
+
+class SymbolError(RQuoteException):
+    """股票代码错误"""
+    pass
+
+
+class NetworkError(RQuoteException):
+    """网络错误"""
+    pass
+
+
+class CacheError(RQuoteException):
+    """缓存错误"""
+    pass
+
+
+class HTTPError(RQuoteException):
+    """HTTP错误（向后兼容）"""
+    pass
+

rquote/factors/__init__.py

@@ -0,0 +1,8 @@
+# -*- coding: utf-8 -*-
+"""
+因子计算模块
+"""
+from .technical import BasicFactors
+
+__all__ = ['BasicFactors']
+

rquote/factors/technical.py

@@ -0,0 +1,150 @@
+# -*- coding: utf-8 -*-
+"""
+技术因子
+"""
+import pandas as pd
+from typing import Union
+
+
+class BasicFactors:
+    """基础技术因子"""
+    
+    @staticmethod
+    def break_rise(d: pd.DataFrame) -> float:
+        """
+        突破上涨
+        
+        Args:
+            d: 价格数据DataFrame
+        
+        Returns:
+            突破上涨幅度
+        """
+        if d.open[-1] / d.close[-2] > 1.002 and d.close[-1] > d.open[-1]:
+            return round((d.open[-1] - d.close[-2]) / d.close[-2], 2)
+        else:
+            return 0
+    
+    @staticmethod
+    def min_resist(d: pd.DataFrame) -> float:
+        """
+        最小阻力
+        
+        Args:
+            d: 价格数据DataFrame
+        
+        Returns:
+            最小阻力值
+        """
+        sup, pre, pcur = 0, 0, d.close[-1]
+        for i in d.iterrows():
+            p = (i[1].open + i[1].close) / 2
+            if p > pcur:
+                pre += i[1].vol
+            if p < pcur:
+                sup += i[1].vol
+        minres = (sup - pre) / (sup + pre)
+        if abs(minres - 1) < .01 and d.close[-2] < max(d.close[:-2]):
+            minres += .2
+        minres = round(minres, 2)
+        return minres
+    
+    @staticmethod
+    def vol_extreme(d: pd.DataFrame):
+        """
+        成交量极值
+        
+        Args:
+            d: 价格数据DataFrame
+        
+        Returns:
+            成交量极值比率
+        """
+        vol_series = d.vol
+        v60max = vol_series.rolling(60).max()
+        v60min = vol_series.rolling(60).min()
+        # any in last 3days
+        for i in range(1, 3):
+            if vol_series[-i] > v60max[-i - 1]:
+                return round(vol_series[-i] / v60max[-i - 1], 2)
+            if vol_series[-i] < v60min[-i - 1]:
+                return round(-vol_series[-i] / v60min[-i - 1], 2)
+        return 0
+    
+    @staticmethod
+    def bias_rate_over_ma60(d: pd.DataFrame) -> float:
+        """
+        偏离MA60的比率
+        
+        Args:
+            d: 价格数据DataFrame
+        
+        Returns:
+            偏离比率
+        """
+        r60 = d.close - d.close.rolling(60).mean()
+        if r60[-1] > 0:
+            return round(r60[-1] / r60.rolling(60).max()[-1], 2)
+        else:
+            return round(-r60[-1] / r60.rolling(60).min()[-1], 2)
+    
+    @staticmethod
+    def op_ma(d: pd.DataFrame) -> Union[float, None]:
+        """
+        MA评分
+        
+        Args:
+            d: 价格数据DataFrame
+        
+        Returns:
+            MA评分
+        """
+        if len(d) < 22:
+            return None
+        
+        d = d.copy()
+        d['mv5'] = d.close.rolling(5).mean()
+        d['mv10'] = d.close.rolling(10).mean()
+        d['mv20'] = d.close.rolling(20).mean()
+        d['mv60'] = d.close.rolling(60).mean()
+        
+        def ma20(d):
+            ret = 0
+            # .2 for over ma60
+            if d.close[-1] > d.mv60[-1]:
+                ret += 0.2
+            # .2 for all upwards ma's
+            if (d.mv5[-1] > d.mv5[-2] and d.mv10[-1] >
+                    d.mv10[-2] and d.mv20[-1] > d.mv20[-2]):
+                ret += 0.2
+                for j in range(1, 3):
+                    if not (d.close[-j] > d.mv5[-j] and d.close[-j]
+                            > d.mv10[-j] and d.close[-j] > d.mv20[-j]):
+                        return ret
+                for j in range(3, 5):
+                    if (d.close[-j] > d.mv5[-j] and d.close[-j] >
+                            d.mv10[-j] and d.close[-j] > d.mv20[-j]):
+                        return ret
+                # .2 for just rush over ma's (fresh score)
+                ret += 0.2
+            return ret
+        return ma20(d)
+    
+    @staticmethod
+    def op_cnt(d: pd.DataFrame, cont_min: int = 3) -> int:
+        """
+        连续上涨天数计数
+        
+        Args:
+            d: 价格数据DataFrame
+            cont_min: 最小连续天数
+        
+        Returns:
+            连续上涨天数
+        """
+        d.index = pd.DatetimeIndex(d.index)
+        td = (d.p_change_on_sh.rolling(cont_min).min() > 0).astype(int) * \
+            (d.p_change.rolling(cont_min).min() > 0).astype(int)
+        ret = 0 if td[-1] <= 0 else td[-1]
+        return ret
+

rquote/markets/__init__.py

@@ -0,0 +1,14 @@
+# -*- coding: utf-8 -*-
+"""
+市场模块
+"""
+from .base import Market
+from .cn_stock import CNStockMarket
+from .hk_stock import HKStockMarket
+from .us_stock import USStockMarket
+from .future import FutureMarket
+from .factory import MarketFactory
+
+__all__ = ['Market', 'CNStockMarket', 'HKStockMarket', 'USStockMarket', 
+           'FutureMarket', 'MarketFactory']
+

rquote/markets/base.py

@@ -0,0 +1,49 @@
+# -*- coding: utf-8 -*-
+"""
+市场基类
+"""
+from abc import ABC, abstractmethod
+from typing import Tuple, Optional
+import pandas as pd
+from ..cache import Cache
+from ..data_sources.base import DataSource
+
+
+class Market(ABC):
+    """市场基类"""
+    
+    def __init__(self, data_source: DataSource, cache: Optional[Cache] = None):
+        """
+        初始化市场
+        
+        Args:
+            data_source: 数据源
+            cache: 缓存对象
+        """
+        self.data_source = data_source
+        self.cache = cache
+    
+    @abstractmethod
+    def get_price(self, symbol: str, sdate: str = '', edate: str = '', 
+                  freq: str = 'day', days: int = 320, fq: str = 'qfq') -> Tuple[str, str, pd.DataFrame]:
+        """获取价格数据"""
+        pass
+    
+    @abstractmethod
+    def normalize_symbol(self, symbol: str) -> str:
+        """标准化股票代码"""
+        pass
+    
+    def _get_cached(self, key: str) -> Optional[Tuple[str, str, pd.DataFrame]]:
+        """从缓存获取数据"""
+        if self.cache:
+            cached = self.cache.get(key)
+            if cached:
+                return cached
+        return None
+    
+    def _put_cache(self, key: str, value: Tuple[str, str, pd.DataFrame]) -> None:
+        """存入缓存"""
+        if self.cache:
+            self.cache.put(key, value)
+

rquote/markets/cn_stock.py

@@ -0,0 +1,186 @@
+# -*- coding: utf-8 -*-
+"""
+A股市场
+"""
+import json
+import base64
+import pandas as pd
+from typing import Tuple
+from .base import Market
+from ..parsers import KlineParser
+from ..exceptions import DataSourceError, ParseError
+from ..utils import hget, logger
+
+
+class CNStockMarket(Market):
+    """A股市场"""
+    
+    def normalize_symbol(self, symbol: str) -> str:
+        """标准化A股代码"""
+        if symbol[0] in ['0', '1', '3', '5', '6']:
+            prefix = 'sh' if symbol[0] in ['5', '6'] else 'sz'
+            return prefix + symbol
+        return symbol
+    
+    def get_price(self, symbol: str, sdate: str = '', edate: str = '', 
+                  freq: str = 'day', days: int = 320, fq: str = 'qfq') -> Tuple[str, str, pd.DataFrame]:
+        """获取A股价格数据"""
+        symbol = self.normalize_symbol(symbol)
+        
+        # 检查缓存
+        cache_key = f"{symbol}:{sdate}:{edate}:{freq}:{days}:{fq}"
+        cached = self._get_cached(cache_key)
+        if cached:
+            return cached
+        
+        # 特殊处理BK（板块）代码
+        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)
+        
+        # 使用数据源获取数据
+        try:
+            raw_data = self.data_source.fetch_kline(
+                symbol, freq=freq, sdate=sdate, edate=edate, days=days, fq=fq
+            )
+            
+            # 使用解析器解析
+            parser = KlineParser()
+            name, df = parser.parse_tencent_kline(raw_data, symbol)
+            
+            result = (symbol, name, df)
+            self._put_cache(cache_key, result)
+            return result
+        except (DataSourceError, ParseError) as e:
+            logger.warning(f'Failed to fetch {symbol} using new architecture: {e}')
+            # 降级到旧方法
+            return self._get_price_fallback(symbol, sdate, edate, freq, days, fq)
+    
+    def _get_bk_price(self, symbol: str) -> Tuple[str, str, pd.DataFrame]:
+        """获取板块价格（BK开头）"""
+        try:
+            url = base64.b64decode('aHR0cDovL3B1c2gyaGlzLmVhc3' +
+                                   'Rtb25leS5jb20vYXBpL3F0L3N0b2NrL2tsaW5lL2dldD9jYj1qUX' +
+                                   'VlcnkxMTI0MDIyNTY2NDQ1ODczNzY2OTcyXzE2MTc4NjQ1NjgxMz' +
+                                   'Emc2VjaWQ9OTAu').decode() + symbol + \
+                              '&fields1=f1%2Cf2%2Cf3%2Cf4%2Cf5' + \
+                              '&fields2=f51%2Cf52%2Cf53%2Cf54%2Cf55%2Cf56%2Cf57%2Cf58' + \
+                              '&klt=101&fqt=0&beg=19900101&end=20990101&_=1'
+            response = hget(url)
+            if not response:
+                logger.warning(f'{symbol} hget failed')
+                return symbol, 'None', pd.DataFrame([])
+            
+            data = json.loads(response.text.split('jQuery1124022566445873766972_1617864568131(')[1][:-2])
+            if not data.get('data'):
+                logger.warning(f'{symbol} data empty')
+                return symbol, 'None', pd.DataFrame([])
+            
+            name = data['data']['name']
+            df = pd.DataFrame([i.split(',') for i in data['data']['klines']], 
+                             columns=['date', 'open', 'close', 'high', 'low', 'vol', 'money', 'p'])
+            df = df.set_index(['date']).astype(float)
+            
+            result = (symbol, name, df)
+            self._put_cache(symbol, result)
+            return result
+        except Exception as e:
+            logger.warning(f'error fetching {symbol}, err: {e}')
+            return symbol, 'None', pd.DataFrame([])
+    
+    def _get_pt_price(self, symbol: str, sdate: str, edate: str, 
+                     freq: str, days: int, fq: str) -> Tuple[str, str, pd.DataFrame]:
+        """获取PT代码价格"""
+        try:
+            url = f'https://proxy.finance.qq.com/ifzqgtimg/appstock/app/newfqkline/get?_var=kline_dayqfq&param={symbol},{freq},{sdate},{edate},{days},{fq}'
+            response = hget(url)
+            if not response:
+                logger.warning(f'{symbol} hget failed')
+                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')
+                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")}')
+                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)
+                return result
+            except Exception as e:
+                logger.warning(f'Failed to parse {symbol}, using fallback: {e}')
+                # 降级处理
+                symbol_data = data.get('data', {}).get(symbol, {})
+                if not symbol_data:
+                    return symbol, 'None', pd.DataFrame([])
+                
+                tk = None
+                for tkt in ['day', 'qfqday', 'hfqday', 'week', 'qfqweek', 'hfqweek',
+                            'month', 'qfqmonth', 'hfqmonth']:
+                    if tkt in symbol_data:
+                        tk = tkt
+                        break
+                
+                if not tk:
+                    return symbol, 'None', pd.DataFrame([])
+                
+                name = ''
+                if 'qt' in symbol_data and symbol in symbol_data['qt']:
+                    name = symbol_data['qt'][symbol][1] if len(symbol_data['qt'][symbol]) > 1 else ''
+                
+                kline_data = symbol_data[tk]
+                df = pd.DataFrame([j[:6] for j in kline_data],
+                                 columns=['date', 'open', 'close', 'high', 'low', 'vol']).set_index('date')
+                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)
+                return result
+        except Exception as e:
+            logger.warning(f'error fetching {symbol}, err: {e}')
+            return symbol, 'None', pd.DataFrame([])
+    
+    def _get_price_fallback(self, symbol: str, sdate: str, edate: str, 
+                           freq: str, days: int, fq: str) -> Tuple[str, str, pd.DataFrame]:
+        """降级方法（旧实现）"""
+        from ..utils import hget
+        import json
+        
+        url = f'http://web.ifzq.gtimg.cn/appstock/app/newfqkline/get?param={symbol},{freq},{sdate},{edate},{days},{fq}'
+        response = hget(url)
+        if not response:
+            raise DataSourceError(f'Failed to fetch data for {symbol}')
+        
+        data = json.loads(response.text)['data'][symbol]
+        name = ''
+        for tkt in ['day', 'qfqday', 'hfqday', 'week', 'qfqweek', 'hfqweek',
+                    'month', 'qfqmonth', 'hfqmonth']:
+            if tkt in data:
+                tk = tkt
+                break
+        
+        df = pd.DataFrame([j[:6] for j in data[tk]],
+                         columns=['date', 'open', 'close', 'high', 'low', 'vol']).set_index('date')
+        for col in ['open', 'high', 'low', 'close', 'vol']:
+            df[col] = pd.to_numeric(df[col], errors='coerce')
+        if 'qt' in data:
+            name = data['qt'][symbol][1]
+        
+        result = (symbol, name, df)
+        cache_key = f"{symbol}:{sdate}:{edate}:{freq}:{days}:{fq}"
+        self._put_cache(cache_key, result)
+        return result
+