hikyuu 2.6.8.4__py3-none-manylinux2014_x86_64.whl → 2.7.0__py3-none-manylinux2014_x86_64.whl

hikyuu/fetcher/stock/zh_stock_a_pytdx.py

@@ -1,129 +0,0 @@
-# coding:utf-8
-#
-# The MIT License (MIT)
-#
-# Created on: 2020-11-29
-#     Author: fasiondog
-
-import datetime
-from concurrent import futures
-from pytdx.hq import TdxHq_API
-from hikyuu.data.common_pytdx import search_best_tdx
-from hikyuu import get_stock, constant
-from hikyuu.util import *
-
-
-@hku_catch(ret=None, callback=lambda quotes: hku_warn(quotes))
-def parse_one_result(quotes):
-    result = {}
-    hku_check_ignore(quotes, "Invalid input param!")
-    try:
-        result['datetime'] = datetime.datetime.combine(
-            datetime.date.today(), datetime.time.fromisoformat(quotes['servertime'])
-        )
-    except:
-        return None
-
-    result['market'] = 'SH' if quotes['market'] == 1 else 'SZ'
-    result['code'] = quotes['code']
-    result['name'] = ''
-    result['open'] = quotes['open']  # 今日开盘价
-    result['yesterday_close'] = quotes['last_close']  # 昨日收盘价
-    result['close'] = quotes['price']  # 当前价格
-    result['high'] = quotes['high']  # 今日最高价
-    result['low'] = quotes['low']  # 今日最低价
-    result['bid'] = float(quotes['bid1'])  # 竞买价，即“买一”报价
-    result['ask'] = float(quotes['ask1'])  # 竞卖价，即“卖一”报价
-    # 指数 volumn 需要乘以 0.01
-    stk = get_stock(f"{result['market']}{result['code']}")
-    if not stk.is_null() and stk.type == constant.STOCKTYPE_INDEX:
-        result['volume'] = float(quotes['vol']) * 0.01
-    else:
-        result['volume'] = float(quotes['vol'])  # 成交的股票手数
-    result['amount'] = round(quotes['amount'] * 0.0001, 2)  # 成交金额，单位为“元”，若要以“万元”为成交金额的单位，需要把该值除以一万
-
-    result['bid'] = [float(quotes['bid1']), float(quotes['bid2']), float(
-        quotes['bid3']), float(quotes['bid4']), float(quotes['bid5'])]
-    result['bid_amount'] = [float(quotes['bid_vol1']), float(quotes['bid_vol2']), float(
-        quotes['bid_vol3']), float(quotes['bid_vol4']), float(quotes['bid_vol5'])]
-    result['ask'] = [float(quotes['ask1']), float(quotes['ask2']), float(
-        quotes['ask3']), float(quotes['ask4']), float(quotes['ask5'])]
-    result['ask_amount'] = [float(quotes['ask_vol1']), float(quotes['ask_vol2']), float(
-        quotes['ask_vol3']), float(quotes['ask_vol4']), float(quotes['ask_vol5'])]
-    return result
-
-
-@hku_catch(ret=[], trace=True)
-def request_data(api, stklist, parse_one_result):
-    """请求失败将抛出异常"""
-    quotes_list = api.get_security_quotes(stklist)
-    result = [parse_one_result(q) for q in quotes_list] if quotes_list is not None else []
-    return [r for r in result if r is not None]
-
-
-@hku_catch(ret=([], []))
-def inner_get_spot(stocklist, ip, port, batch_func=None):
-    api = TdxHq_API()
-    hku_check(api.connect(ip, port), 'Failed connect tdx ({}:{})!'.format(ip, port))
-
-    count = 0
-    tmplist = []
-    result = []
-    max_size = 80
-    err_list = []
-    for stk in stocklist:
-        tmplist.append((1 if stk.market == 'SH' else 0, stk.code))
-        count += 1
-        if count >= max_size:
-            phase_result = request_data(api, tmplist, parse_one_result)
-            if phase_result:
-                result.extend(phase_result)
-                if batch_func:
-                    batch_func(phase_result)
-            else:
-                err_list.extend(tmplist)
-            count = 0
-            tmplist = []
-    if tmplist:
-        phase_result = request_data(api, tmplist, parse_one_result)
-        if phase_result:
-            result.extend(phase_result)
-            if batch_func:
-                batch_func(phase_result)
-        else:
-            err_list.extend(tmplist)
-    api.disconnect()
-    return result, err_list
-
-
-@spend_time
-def get_spot(stocklist, ip, port, batch_func=None):
-    hosts = search_best_tdx()
-    hosts_cnt = len(hosts)
-    num = len(stocklist) // hosts_cnt
-    batchslist = []
-    for i in range(hosts_cnt):
-        batchslist.append([[stk for stk in stocklist[i*num: (i+1)*num]], hosts[i][2], hosts[i][3], batch_func])
-    if len(stocklist) % hosts_cnt != 0:
-        pos = num * hosts_cnt
-        for i in range(hosts_cnt):
-            batchslist[i][0].append(stocklist[pos])
-            pos += 1
-            if pos >= len(stocklist):
-                break
-
-    def do_inner(param):
-        ret = inner_get_spot(param[0], param[1], param[2], param[3])
-        return ret
-
-    with futures.ThreadPoolExecutor() as executor:
-        res = executor.map(do_inner, batchslist, timeout=10)
-
-    result = []
-    errors = []
-    for batch_result in res:
-        if batch_result[0]:
-            result.extend(batch_result[0])
-        if batch_result[1]:
-            errors.extend(batch_result[1])
-    return result, errors

hikyuu/gui/data/CollectToMemThread.py

@@ -1,123 +0,0 @@
-#!/usr/bin/python
-# -*- coding: utf8 -*-
-# cp936
-import logging
-import time
-import datetime
-from math import ceil
-from PyQt5.QtCore import QThread, QWaitCondition, QMutex
-
-from hikyuu import Datetime, TimeDelta, hikyuu_init, StockManager, constant
-from hikyuu.util import *
-from hikyuu.fetcher.stock.zh_stock_a_sina_qq import get_spot
-from hikyuu.data.sqlite_mem import SqliteMemDriver
-
-
-class CollectToMemThread(QThread):
-    def __init__(self, config, hku_config_file, market='SH'):
-        super(self.__class__, self).__init__()
-        self.working = True
-        self._config = config
-        self.hku_config_file = hku_config_file
-        self.market = market.lower()
-        self.marketid = None
-        self._interval = TimeDelta(seconds=config.getint('collect', 'interval', fallback=60 * 60))
-        self._phase1_start_time = Datetime(
-            datetime.datetime.combine(
-                datetime.date.today(),
-                datetime.time.fromisoformat((config.get('collect', 'phase1_start', fallback='09:05')))
-            )
-        )
-        self._phase1_end_time = Datetime(
-            datetime.datetime.combine(
-                datetime.date.today(),
-                datetime.time.fromisoformat((config.get('collect', 'phase1_end', fallback='09:05')))
-            )
-        )
-        self._use_zhima_proxy = config.getboolean('collect', 'use_zhima_proxy', fallback=False)
-
-        self.cond = QWaitCondition()
-        self.mutex = QMutex()
-
-    def stop(self):
-        if self.working:
-            self.working = False
-            self.cond.wakeAll()
-            self.wait()
-
-    def __del__(self):
-        self.stop()
-
-    @hku_catch()
-    def run(self):
-        self.logger.info("{} 数据采集同步线程启动".format(self.market))
-        self.db = SqliteMemDriver()
-
-        hikyuu_init(self.hku_config_file, ignore_preload=True)
-
-        stk_list = self.get_stock_list()
-        hku_warn_if(not stk_list, "从数据库中获取的股票列表为空！", logger=self.logger)
-        self.mutex.tryLock()
-
-        end_delta = self._phase1_end_time - self._phase1_end_time.start_of_day()
-        start_delta = self._phase1_start_time - self._phase1_start_time.start_of_day()
-
-        start = Datetime.now()
-        if self._phase1_start_time >= self._phase1_end_time:
-            delta = TimeDelta(0)
-        elif start >= self._phase1_end_time:
-            delta = (self._phase1_start_time + TimeDelta(1) - start)
-        elif start < self._phase1_start_time:
-            delta = (self._phase1_start_time - start)
-        else:
-            delta = self._interval * ceil((start - self._phase1_start_time) / self._interval
-                                          ) - (start - self._phase1_start_time)
-
-        hku_info('{} 下次采集时间：{}', self.market, start + delta, logger=self.logger)
-        delta = int(delta.total_milliseconds())
-        while self.working and not self.cond.wait(self.mutex, int(delta)):
-            last_time = Datetime.today() + end_delta
-            start = Datetime.now()
-            if start >= last_time:
-                next_time = Datetime.today() + TimeDelta(1) + start_delta
-                hku_info('{} 明日采集时间：{}', self.market, next_time, logger=self.logger)
-                delta = next_time - start
-                delta = int(delta.total_milliseconds())
-                continue
-            hku_trace("start：{}".format(start))
-            self.collect(stk_list)
-            end = Datetime.now()
-            x = end - start
-            if x + TimeDelta(seconds=1) < self._interval:
-                delta = self._interval - x - TimeDelta(seconds=1)
-                delta = int(delta.total_milliseconds())
-                self.logger.info("{} {:<.2f} 秒后重新采集".format(self.market, delta / 1000))
-                # self.sleep(delta)
-
-        self.db.close()
-        self.logger.info("{} 数据采集同步线程终止!".format(self.market))
-
-    @hku_catch(retry=2, ret=[])
-    def get_stock_list(self):
-        sm = StockManager.instance()
-        return [
-            stk.market_code.lower() for stk in sm
-            if stk.type in (constant.STOCKTYPE_A, constant.STOCKTYPE_INDEX,
-                            constant.STOCKTYPE_GEM, constant.STOCKTYPE_A_BJ) and stk.valid and stk.market.lower() == self.market.lower()
-        ]
-
-    def record_is_valid(self, record):
-        return record['amount'] > 0.0 and record['volume'] > 0.0 \
-            and record['high'] >= record['open'] >= record['low'] > 0.0 \
-            and record['high'] >= record['close'] >= record['low']
-
-    @hku_catch()
-    def collect(self, stk_list):
-        record_list = get_spot(stk_list, source='sina', use_proxy=self._use_zhima_proxy)
-        hku_info("{} 网络获取数量：{}".format(self.market, len(record_list)))
-        record_list = [r for r in record_list if self.record_is_valid(r)]
-        self.db.insert_bars(self.market, record_list, 'day')
-        self.db.insert_bars(self.market, record_list, 'min')
-
-
-class_logger(CollectToMemThread)

hikyuu/gui/data/CollectToMySQLThread.py

@@ -1,178 +0,0 @@
-#!/usr/bin/python
-# -*- coding: utf8 -*-
-# cp936
-import logging
-import time
-import datetime
-from math import ceil
-from PyQt5.QtCore import QThread, QWaitCondition, QMutex
-
-import mysql.connector
-from mysql.connector import errorcode
-
-from hikyuu import Datetime, TimeDelta
-from hikyuu.util import *
-from hikyuu.data.common_mysql import get_stock_list, get_marketid, get_table
-from hikyuu.fetcher.stock.zh_stock_a_sina_qq import get_spot
-
-
-class CollectToMySQLThread(QThread):
-    def __init__(self, config, market='SH'):
-        super(self.__class__, self).__init__()
-        self.working = True
-        self._config = config
-        self.market = market.lower()
-        self.marketid = None
-        assert config.getboolean("mysql", "enable", fallback=False)
-        self._db_config = {
-            'user': config['mysql']['usr'],
-            'password': config['mysql']['pwd'],
-            'host': config['mysql']['host'],
-            'port': config['mysql']['port']
-        }
-        self._connect = None
-        self.quotations = [
-            'stock',
-        ]  # sina 不支持基金，qq支持，此处屏蔽基金
-        # if config['quotation']['stock']:
-        #    self.quotations.append('stock')
-        # if config['quotation']['fund']:
-        #    self.quotations.append('fund')
-        # self.logger.info(self.quotations)
-
-        self._interval = TimeDelta(seconds=config.getint('collect', 'interval', fallback=60 * 60))
-        self._phase1_start_time = Datetime(
-            datetime.datetime.combine(
-                datetime.date.today(),
-                datetime.time.fromisoformat((config.get('collect', 'phase1_start', fallback='09:05')))
-            )
-        )
-        self._phase1_end_time = Datetime(
-            datetime.datetime.combine(
-                datetime.date.today(),
-                datetime.time.fromisoformat((config.get('collect', 'phase1_end', fallback='09:05')))
-            )
-        )
-        self._use_zhima_proxy = config.getboolean('collect', 'use_zhima_proxy', fallback=False)
-
-        self.cond = QWaitCondition()
-        self.mutex = QMutex()
-
-    def stop(self):
-        if self.working:
-            self.working = False
-            self.cond.wakeAll()
-            self.wait()
-            if self._connect is not None:
-                hku_trace('关闭数据库连接', logger=self.logger)
-                self._connect.close()
-
-    def __del__(self):
-        self.stop()
-
-    @hku_catch()
-    def run(self):
-        self.logger.info("{} 数据采集同步线程启动".format(self.market))
-        stk_list = self.get_stock_list()
-        hku_warn_if(not stk_list, "从数据库中获取的股票列表为空！", logger=self.logger)
-        self.mutex.tryLock()
-
-        end_delta = self._phase1_end_time - self._phase1_end_time.start_of_day()
-        start_delta = self._phase1_start_time - self._phase1_start_time.start_of_day()
-
-        start = Datetime.now()
-        if self._phase1_start_time >= self._phase1_end_time:
-            delta = TimeDelta(0)
-        elif start >= self._phase1_end_time:
-            delta = (self._phase1_start_time + TimeDelta(1) - start)
-        elif start < self._phase1_start_time:
-            delta = (self._phase1_start_time - start)
-        else:
-            delta = self._interval * ceil((start - self._phase1_start_time) / self._interval
-                                          ) - (start - self._phase1_start_time)
-
-        hku_info('{} 下次采集时间：{}', self.market, start + delta, logger=self.logger)
-        delta = int(delta.total_milliseconds())
-        while self.working and not self.cond.wait(self.mutex, int(delta)):
-            last_time = Datetime.today() + end_delta
-            start = Datetime.now()
-            if start >= last_time:
-                next_time = Datetime.today() + TimeDelta(1) + start_delta
-                hku_info('{} 明日采集时间：{}', self.market, next_time, logger=self.logger)
-                delta = next_time - start
-                delta = int(delta.total_milliseconds())
-                continue
-            hku_trace("start：{}".format(start))
-            self.collect(stk_list)
-            end = Datetime.now()
-            x = end - start
-            if x + TimeDelta(seconds=1) < self._interval:
-                delta = self._interval - x - TimeDelta(seconds=1)
-                delta = int(delta.total_milliseconds())
-                self.logger.info("{} {:<.2f} 秒后重新采集".format(self.market, delta / 1000))
-                # self.sleep(delta)
-
-        self.logger.info("{} 数据采集同步线程终止!".format(self.market))
-
-    def record_is_valid(self, record):
-        return record['amount'] > 0.0 and record['volume'] > 0.0 \
-            and record['high'] >= record['open'] >= record['low'] > 0.0 \
-            and record['high'] >= record['close'] >= record['low']
-
-    @hku_catch(ret=False)
-    def process_one_record(self, record):
-        if not self.record_is_valid(record):
-            return (0, 0)
-        connect = self.get_connect()
-        current_date = Datetime(record['datetime'].date()).number
-        table = get_table(connect, self.market, record['code'], 'day')
-        sql = 'replace into {} (date, open, high, low, close, amount, count) \
-             values ({}, {}, {}, {}, {}, {}, {})'.format(
-            table, current_date, record['open'], record['high'], record['low'], record['close'], record['amount'],
-            record['volume']
-        )
-        cur = connect.cursor()
-        cur.execute(sql)
-        cur.close()
-        return
-
-    @hku_catch()
-    def collect(self, stk_list):
-        record_list = get_spot(stk_list, source='sina', use_proxy=self._use_zhima_proxy)
-        hku_info("{} 网络获取数量：{}".format(self.market, len(record_list)))
-        connect = self.get_connect()
-        if self.marketid == None:
-            self.marketid = get_marketid(connect, self.market)
-        update_count = 0
-        for record in record_list:
-            if not self.working:
-                break
-            if self.process_one_record(record):
-                update_count += 1
-        connect.commit()
-        hku_info("{} 数据库更新记录数：{}".format(self.market, update_count))
-
-    def get_connect(self):
-        if self._connect:
-            return self._connect
-        try:
-            self._connect = mysql.connector.connect(**self._db_config)
-        except mysql.connector.Error as err:
-            if err.errno == errorcode.ER_ACCESS_DENIED_ERROR:
-                self.logger.error("MYSQL密码或用户名错误！")
-            elif err.errno == errorcode.ER_BAD_DB_ERROR:
-                self.logger.error("MySQL数据库不存在！")
-            else:
-                self.logger.error("连接数据库失败，{}".format(err.msg))
-        except:
-            self.logger.error("未知原因导致无法连接数据库！")
-        return self._connect
-
-    @hku_catch(retry=2, ret=[])
-    def get_stock_list(self):
-        connect = self.get_connect()
-        stk_list = get_stock_list(connect, self.market, self.quotations)
-        return ["{}{}".format(self.market.lower(), item[2]) for item in stk_list if item[3] == 1]
-
-
-class_logger(CollectToMySQLThread)