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

rquote/markets/factory.py

@@ -0,0 +1,82 @@
+# -*- coding: utf-8 -*-
+"""
+市场工厂
+"""
+from typing import Optional
+from .base import Market
+from .cn_stock import CNStockMarket
+from .hk_stock import HKStockMarket
+from .us_stock import USStockMarket
+from .future import FutureMarket
+from ..data_sources import TencentDataSource, SinaDataSource
+from ..cache import Cache, MemoryCache
+from ..config import default_config
+
+
+class MarketFactory:
+    """市场工厂类"""
+    
+    @staticmethod
+    def create_from_symbol(symbol: str, cache: Optional[Cache] = None) -> Market:
+        """
+        根据股票代码创建对应的市场实例
+        
+        Args:
+            symbol: 股票代码
+            cache: 缓存对象，如果为None且配置启用缓存，则创建MemoryCache
+        
+        Returns:
+            Market实例
+        """
+        # 处理缓存
+        if cache is None and default_config.cache_enabled:
+            cache = MemoryCache(ttl=default_config.cache_ttl)
+        
+        # 标准化代码
+        if symbol[0] in ['0', '1', '3', '5', '6']:
+            symbol = 'sh' + symbol if symbol[0] in ['5', '6'] else 'sz' + symbol
+        
+        # 根据前缀选择市场
+        if symbol[:2] == 'BK':
+            # 板块，使用A股市场处理
+            return CNStockMarket(TencentDataSource(), cache)
+        elif symbol[:2] == 'fu':
+            return FutureMarket(SinaDataSource(), cache)
+        elif symbol[:2] == 'pt':
+            # PT代码，使用A股市场处理
+            return CNStockMarket(TencentDataSource(), cache)
+        elif symbol[:2] in ['sh', 'sz']:
+            return CNStockMarket(TencentDataSource(), cache)
+        elif symbol[:2] == 'hk':
+            return HKStockMarket(TencentDataSource(), cache)
+        elif symbol[:2] == 'us':
+            return USStockMarket(TencentDataSource(), cache)
+        else:
+            raise ValueError(f'Unsupported symbol format: {symbol}')
+    
+    @staticmethod
+    def create(market_type: str, cache: Optional[Cache] = None) -> Market:
+        """
+        根据市场类型创建市场实例
+        
+        Args:
+            market_type: 市场类型 ('cn_stock', 'hk_stock', 'us_stock', 'future')
+            cache: 缓存对象
+        
+        Returns:
+            Market实例
+        """
+        if cache is None and default_config.cache_enabled:
+            cache = MemoryCache(ttl=default_config.cache_ttl)
+        
+        if market_type == 'cn_stock':
+            return CNStockMarket(TencentDataSource(), cache)
+        elif market_type == 'hk_stock':
+            return HKStockMarket(TencentDataSource(), cache)
+        elif market_type == 'us_stock':
+            return USStockMarket(TencentDataSource(), cache)
+        elif market_type == 'future':
+            return FutureMarket(SinaDataSource(), cache)
+        else:
+            raise ValueError(f'Unsupported market type: {market_type}')
+

rquote/markets/future.py

@@ -0,0 +1,92 @@
+# -*- coding: utf-8 -*-
+"""
+期货市场
+"""
+import json
+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 FutureMarket(Market):
+    """期货市场"""
+    
+    def normalize_symbol(self, symbol: str) -> str:
+        """标准化期货代码"""
+        if not symbol.startswith('fu'):
+            return 'fu' + 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]:
+        """获取期货价格数据"""
+        symbol = self.normalize_symbol(symbol)
+        
+        # 特殊处理BTC
+        if symbol[2:5].lower() == 'btc':
+            return self._get_btc_price(symbol)
+        
+        cache_key = f"{symbol}:{sdate}:{edate}:{freq}:{days}"
+        cached = self._get_cached(cache_key)
+        if cached:
+            return cached
+        
+        future_code = symbol[2:]  # 去掉'fu'前缀
+        
+        try:
+            raw_data = self.data_source.fetch_kline(future_code, freq=freq)
+            parser = KlineParser()
+            df = parser.parse_sina_future_kline(raw_data, freq=freq)
+            
+            result = (symbol, future_code, df)
+            self._put_cache(cache_key, result)
+            return result
+        except (DataSourceError, ParseError) as e:
+            logger.warning(f'Failed to fetch {symbol} using new architecture, falling back: {e}')
+            return self._get_price_fallback(symbol, future_code, freq)
+    
+    def _get_btc_price(self, symbol: str) -> Tuple[str, str, pd.DataFrame]:
+        """获取比特币价格"""
+        url = 'https://quotes.sina.cn/fx/api/openapi.php/BtcService.getDayKLine?symbol=btcbtcusd'
+        response = hget(url)
+        if not response:
+            raise DataSourceError("Failed to fetch BTC data")
+        
+        data = json.loads(response.text)['result']['data'].split('|')
+        df = pd.DataFrame([i.split(',') for i in data], 
+                          columns=['date', 'open', 'high', 'low', 'close', 'vol', 'amount'])
+        for col in ['open', 'high', 'low', 'close', 'vol', 'amount']:
+            df[col] = pd.to_numeric(df[col], errors='coerce')
+        df = df.set_index('date').astype(float)
+        
+        result = (symbol, 'BTC', df)
+        self._put_cache(symbol, result)
+        return result
+    
+    def _get_price_fallback(self, symbol: str, future_code: str, freq: str) -> Tuple[str, str, pd.DataFrame]:
+        """降级方法"""
+        from ..utils.helpers import load_js_var_json
+        
+        if freq in ('min', '1min', 'minute'):
+            url = f'https://stock2.finance.sina.com.cn/futures/api/jsonp.php/var%20t1nf_{future_code}=/InnerFuturesNewService.getMinLine?symbol={future_code}'
+            df = pd.DataFrame(load_js_var_json(url))
+            df.columns = ['dtime', 'close', 'avg', 'vol', 'hold', 'last_close', 'cur_date']
+            for col in ['close', 'avg', 'vol', 'hold']:
+                df[col] = pd.to_numeric(df[col], errors='coerce')
+            df = df.set_index('dtime')
+            result = (future_code, future_code, df)
+        else:
+            url = f'https://stock2.finance.sina.com.cn/futures/api/jsonp.php/var%20t1nf_{future_code}=/InnerFuturesNewService.getDailyKLine?symbol={future_code}'
+            df = pd.DataFrame(load_js_var_json(url))
+            df.columns = ['date', 'open', 'high', 'low', 'close', 'vol', 'p', 's']
+            for col in ['open', 'high', 'low', 'close', 'vol', 'p', 's']:
+                df[col] = pd.to_numeric(df[col], errors='coerce')
+            df = df.set_index('date').astype(float)
+            result = (symbol, future_code, df)
+        
+        self._put_cache(f"{symbol}:{freq}", result)
+        return result
+

rquote/markets/hk_stock.py

@@ -0,0 +1,46 @@
+# -*- coding: utf-8 -*-
+"""
+港股市场
+"""
+import pandas as pd
+from typing import Tuple
+from .base import Market
+from ..parsers import KlineParser
+from ..exceptions import DataSourceError, ParseError
+from ..utils import logger
+
+
+class HKStockMarket(Market):
+    """港股市场"""
+    
+    def normalize_symbol(self, symbol: str) -> str:
+        """标准化港股代码"""
+        if not symbol.startswith('hk'):
+            return 'hk' + 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]:
+        """获取港股价格数据"""
+        symbol = self.normalize_symbol(symbol)
+        
+        cache_key = f"{symbol}:{sdate}:{edate}:{freq}:{days}:{fq}"
+        cached = self._get_cached(cache_key)
+        if cached:
+            return cached
+        
+        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}: {e}')
+            raise
+

rquote/markets/us_stock.py

@@ -0,0 +1,69 @@
+# -*- coding: utf-8 -*-
+"""
+美股市场
+"""
+import json
+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 USStockMarket(Market):
+    """美股市场"""
+    
+    def normalize_symbol(self, symbol: str) -> str:
+        """标准化美股代码"""
+        if not symbol.startswith('us'):
+            return 'us' + 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]:
+        """获取美股价格数据"""
+        symbol = self.normalize_symbol(symbol)
+        
+        cache_key = f"{symbol}:{sdate}:{edate}:{freq}:{days}:{fq}"
+        cached = self._get_cached(cache_key)
+        if cached:
+            return cached
+        
+        # 特殊处理分钟数据
+        if freq in ('min', '1min', 'minute'):
+            return self._get_minute_data(symbol)
+        
+        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}: {e}')
+            raise
+    
+    def _get_minute_data(self, symbol: str) -> Tuple[str, str, pd.DataFrame]:
+        """获取分钟数据"""
+        url = f'https://web.ifzq.gtimg.cn/appstock/app/UsMinute/query?_var=min_data_{symbol.replace(".", "")}&code={symbol}'
+        response = hget(url)
+        if not response:
+            raise DataSourceError(f'Failed to fetch minute data for {symbol}')
+        
+        data = json.loads(response.text.split('=')[1])['data'][symbol]
+        name = data['qt'][symbol][1]
+        df = pd.DataFrame([i.split() for i in data['data']['data']],
+                          columns=['minute', 'price', 'volume']).set_index('minute')
+        for col in ['price', 'volume']:
+            df[col] = pd.to_numeric(df[col], errors='coerce')
+        
+        result = (symbol, name, df)
+        self._put_cache(f"{symbol}:min", result)
+        return result
+

rquote/parsers/__init__.py

@@ -0,0 +1,8 @@
+# -*- coding: utf-8 -*-
+"""
+数据解析模块
+"""
+from .kline import KlineParser
+
+__all__ = ['KlineParser']
+

rquote/parsers/kline.py

@@ -0,0 +1,104 @@
+# -*- coding: utf-8 -*-
+"""
+K线数据解析器
+"""
+import pandas as pd
+from typing import Dict, Any, Tuple, Optional
+from ..exceptions import ParseError
+
+
+class KlineParser:
+    """K线数据解析器"""
+    
+    @staticmethod
+    def parse_tencent_kline(data: Dict[str, Any], symbol: str) -> Tuple[str, pd.DataFrame]:
+        """
+        解析腾讯K线数据
+        
+        Args:
+            data: 腾讯API返回的数据
+            symbol: 股票代码
+        
+        Returns:
+            (name, DataFrame)
+        """
+        try:
+            symbol_data = data.get('data', {}).get(symbol, {})
+            if not symbol_data:
+                raise ParseError(f"No data for symbol {symbol}")
+            
+            # 查找时间键
+            time_keys = ['day', 'qfqday', 'hfqday', 'week', 'qfqweek', 'hfqweek',
+                        'month', 'qfqmonth', 'hfqmonth']
+            tk = None
+            for tkt in time_keys:
+                if tkt in symbol_data:
+                    tk = tkt
+                    break
+            
+            if not tk:
+                raise ParseError(f"No time key found for {symbol}")
+            
+            # 提取名称
+            name = ''
+            if 'qt' in symbol_data and symbol in symbol_data['qt']:
+                qt_data = symbol_data['qt'][symbol]
+                if len(qt_data) > 1:
+                    name = qt_data[1]
+            
+            # 解析K线数据
+            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')
+            
+            return name, df
+        except Exception as e:
+            raise ParseError(f"Failed to parse Tencent kline data: {e}")
+    
+    @staticmethod
+    def parse_sina_future_kline(data: Dict[str, Any], freq: str = 'day') -> pd.DataFrame:
+        """
+        解析新浪期货K线数据
+        
+        Args:
+            data: 新浪API返回的数据
+            freq: 频率
+        
+        Returns:
+            DataFrame
+        """
+        try:
+            raw_data = data.get('data', [])
+            if not raw_data:
+                raise ParseError("Empty data from Sina")
+            
+            if freq in ('min', '1min', 'minute'):
+                # 分钟数据
+                df = pd.DataFrame(raw_data)
+                if 'dtime' in df.columns:
+                    df = df.set_index('dtime')
+                # 转换数值列
+                numeric_cols = ['close', 'avg', 'vol', 'hold']
+                for col in numeric_cols:
+                    if col in df.columns:
+                        df[col] = pd.to_numeric(df[col], errors='coerce')
+            else:
+                # 日线数据
+                df = pd.DataFrame(
+                    raw_data,
+                    columns=['date', 'open', 'high', 'low', 'close', 'vol', 'p', 's']
+                ).set_index('date')
+                # 转换数值列
+                for col in ['open', 'high', 'low', 'close', 'vol', 'p', 's']:
+                    df[col] = pd.to_numeric(df[col], errors='coerce')
+            
+            return df
+        except Exception as e:
+            raise ParseError(f"Failed to parse Sina future kline data: {e}")
+

rquote/plots.py

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 
-from .main import get_price
+from .api import get_price
 
 
 class PlotUtils:

rquote/utils/__init__.py

@@ -0,0 +1,13 @@
+# -*- coding: utf-8 -*-
+"""
+工具模块
+"""
+from .http import HTTPClient
+from .date import check_date_format
+from .logging import logger, setup_logger
+from .web import WebUtils, hget
+from .helpers import load_js_var_json
+
+__all__ = ['HTTPClient', 'check_date_format', 'logger', 'setup_logger', 
+           'WebUtils', 'hget', 'load_js_var_json']
+

rquote/utils/date.py

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+"""
+日期工具模块
+"""
+import time
+import re
+from typing import Optional
+
+
+def check_date_format(date_str: str) -> str:
+    """
+    检查并标准化日期格式
+    
+    Args:
+        date_str: 日期字符串
+    
+    Returns:
+        标准化后的日期字符串（格式：YYYY-MM-DD）
+    
+    Raises:
+        ValueError: 日期格式无法识别
+    """
+    if not date_str:
+        return ''
+    
+    # 允许格式: YYYY-MM-DD
+    if re.match(r'^\d{4}-\d{2}-\d{2}$', date_str):
+        return date_str
+    
+    # 尝试转换其他格式
+    formats = ["%Y/%m/%d", "%Y%m%d", "%Y.%m.%d", "%Y_%m_%d", "%Y-%m-%d"]
+    for fmt in formats:
+        try:
+            t_struct = time.strptime(date_str, fmt)
+            return time.strftime("%Y-%m-%d", t_struct)
+        except ValueError:
+            continue
+    
+    raise ValueError(f"date format not recognized: {date_str}")
+

rquote/utils/helpers.py

@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-
+"""
+辅助工具函数
+"""
+import json
+from .web import hget
+
+
+def load_js_var_json(url: str):
+    """
+    加载JavaScript变量中的JSON数据
+    
+    Args:
+        url: 请求URL
+    
+    Returns:
+        JSON数据
+    """
+    a = hget(url)
+    if a:
+        a = json.loads(a.text.split('(')[1].split(')')[0])
+    return a
+

rquote/utils/http.py

@@ -0,0 +1,112 @@
+# -*- coding: utf-8 -*-
+"""
+HTTP客户端模块
+"""
+import time
+import logging
+import httpx
+from typing import Optional, Dict
+from ..config import default_config
+
+logger = logging.getLogger(__name__)
+
+
+class HTTPClient:
+    """改进的HTTP客户端"""
+    
+    def __init__(self, timeout: Optional[int] = None, retry_times: Optional[int] = None,
+                 retry_delay: Optional[float] = None, pool_size: Optional[int] = None):
+        """
+        初始化HTTP客户端
+        
+        Args:
+            timeout: 超时时间（秒）
+            retry_times: 重试次数
+            retry_delay: 重试延迟（秒）
+            pool_size: 连接池大小
+        """
+        self.timeout = timeout or default_config.http_timeout
+        self.retry_times = retry_times or default_config.http_retry_times
+        self.retry_delay = retry_delay or default_config.http_retry_delay
+        pool_size = pool_size or default_config.http_pool_size
+        
+        self.client = httpx.Client(
+            timeout=self.timeout,
+            limits=httpx.Limits(
+                max_keepalive_connections=pool_size,
+                max_connections=pool_size * 2
+            )
+        )
+    
+    def get(self, url: str, **kwargs) -> Optional[httpx.Response]:
+        """
+        带重试的GET请求
+        
+        Args:
+            url: 请求URL
+            **kwargs: 传递给httpx.get的其他参数
+        
+        Returns:
+            Response对象，失败返回None
+        """
+        headers = kwargs.pop('headers', {})
+        headers.update(self._get_default_headers())
+        
+        for attempt in range(self.retry_times):
+            try:
+                response = self.client.get(
+                    url,
+                    headers=headers,
+                    **kwargs
+                )
+                response.raise_for_status()
+                return response
+            except httpx.HTTPError as e:
+                if attempt == self.retry_times - 1:
+                    logger.error(f'Failed to fetch {url} after {self.retry_times} attempts: {e}')
+                    raise
+                logger.warning(f'Attempt {attempt + 1} failed for {url}, retrying...')
+                time.sleep(self.retry_delay * (attempt + 1))
+        
+        return None
+    
+    def _get_default_headers(self) -> Dict[str, str]:
+        """获取默认请求头"""
+        import uuid
+        from .web import WebUtils
+        return {
+            'User-Agent': WebUtils.ua(),
+            'Referer': str(uuid.uuid4())
+        }
+    
+    def close(self):
+        """关闭客户端"""
+        self.client.close()
+    
+    def __enter__(self):
+        return self
+    
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+
+
+# 全局HTTP客户端实例（向后兼容）
+_default_client = HTTPClient()
+
+def hget_new(url: str, **kwargs) -> Optional[httpx.Response]:
+    """
+    改进的HTTP GET函数
+    
+    Args:
+        url: 请求URL
+        **kwargs: 传递给httpx.get的其他参数
+    
+    Returns:
+        Response对象，失败返回None
+    """
+    try:
+        return _default_client.get(url, **kwargs)
+    except Exception as e:
+        logger.error(f'hget failed for {url}: {e}')
+        return None
+

rquote/utils/logging.py

@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+"""
+日志工具
+"""
+import logging
+
+
+def setup_logger():
+    """设置日志记录器"""
+    logger = logging.getLogger('rquote')
+    if not logger.handlers:
+        logger.setLevel(logging.INFO)
+        file_handler = logging.FileHandler('/tmp/rquote.log')
+        
+        formatter = logging.Formatter('%(asctime)-15s:%(lineno)s %(message)s')
+        file_handler.setFormatter(formatter)
+        
+        logger.addHandler(file_handler)
+        logger.addHandler(logging.StreamHandler())
+    
+    return logger
+
+
+logger = setup_logger()
+