异常保护

Administrator

4 天以前 48fb7a00951f91bdc707e5dd2d196e5bccb752c3

 l2/transaction_progress.py

@@ -5,58 +5,95 @@
# 买入队列
import itertools
import json
import time

import constant
from db import redis_manager
from db import redis_manager_delegate as redis_manager
from db.redis_manager_delegate import RedisUtils
from utils import tool
import l2.l2_data_util
from logs_.log import logger_l2_trade_buy_queue, logger_l2_trade_buy_progress
from log_module.log import logger_l2_trade_buy_queue, logger_l2_trade_buy_progress


class TradeBuyQueue:
    buy_progress_index_cache = {}
    latest_buy_progress_index_cache = {}
    # 成交速率
    trade_speed_cache = {}

    __db = 0
    __redis_manager = redis_manager.RedisManager(0)
    __instance = None

    def __new__(cls, *args, **kwargs):
        if not cls.__instance:
            cls.__instance = super(TradeBuyQueue, cls).__new__(cls, *args, **kwargs)
            cls.__load_datas()
        return cls.__instance

    def __init__(self):
        self.last_buy_queue_data = {}

    def __getRedis(self):
        return self.__redis_manager.getRedis()
    @classmethod
    def __get_redis(cls):
        return cls.__redis_manager.getRedis()

    @classmethod
    def __load_datas(cls):
        __redis = cls.__get_redis()
        try:
            keys = RedisUtils.keys(__redis, "trade_buy_progress_index-*")
            for k in keys:
                code = k.split("-")[-1]
                val = RedisUtils.get(__redis, k)
                val = json.loads(val)
                tool.CodeDataCacheUtil.set_cache(cls.buy_progress_index_cache, code, val)

        finally:
            RedisUtils.realse(__redis)

    def __save_buy_queue_data(self, code, num_list):
        key = "trade_buy_queue_data-{}".format(code)
        self.__getRedis().setex(key, tool.get_expire(), json.dumps((num_list, tool.get_now_time_str())))
        RedisUtils.setex(self.__get_redis(), key, tool.get_expire(), json.dumps((num_list, tool.get_now_time_str())))

    # 返回数据与更新时间
    def __get_buy_queue_data(self, code):
        key = "trade_buy_queue_data-{}".format(code)
        val = self.__getRedis().get(key)
        val = RedisUtils.get(self.__get_redis(), key)
        if val is None:
            return None, None
        val = json.loads(val)
        return val[0], [1]

    def __save_buy_progress_index(self, code, index, is_default):
        tool.CodeDataCacheUtil.set_cache(self.buy_progress_index_cache, code, (index, is_default))
        key = "trade_buy_progress_index-{}".format(code)
        self.__getRedis().setex(key, tool.get_expire(), json.dumps((index, is_default)))
        RedisUtils.setex_async(self.__db, key, tool.get_expire(), json.dumps((index, is_default)))
        # 返回数据与更新时间

    def __get_buy_progress_index(self, code):
        key = "trade_buy_progress_index-{}".format(code)
        val = self.__getRedis().get(key)
        val = RedisUtils.get(self.__get_redis(), key)
        if val is None:
            return None, True
        val = json.loads(val)
        return int(val[0]), bool(val[1])

    def __get_buy_progress_index_cache(self, code):
        cache_result = tool.CodeDataCacheUtil.get_cache(self.buy_progress_index_cache, code)
        if cache_result[0]:
            return cache_result[1]
        return None, True

    # 最近的非涨停买1的时间
    def __save_latest_not_limit_up_time(self, code, time_str):
        key = "latest_not_limit_up_time-{}".format(code)
        self.__getRedis().setex(key, tool.get_expire(), time_str)
        RedisUtils.setex(self.__get_redis(), key, tool.get_expire(), time_str)

    def __get_latest_not_limit_up_time(self, code):
        key = "latest_not_limit_up_time-{}".format(code)
        if not constant.TEST:
            return self.__getRedis().get(key)
            return RedisUtils.get(self.__get_redis(), key)
        return None

    # 保存数据,返回保存数据的条数
@@ -74,7 +111,7 @@
                return None
        self.last_buy_queue_data[code] = queues

        if abs(float(buy_1_price) - float(limit_up_price)) >= 0.01:
        if abs(float(buy_1_price) - float(limit_up_price)) >= 0.001:
            # 保存最近的涨停起始时间
            self.__save_latest_not_limit_up_time(code, buy_1_time)
            return None
@@ -145,11 +182,29 @@

    # 获取成交进度索引
    def get_traded_index(self, code):
        index, is_default = self.__get_buy_progress_index(code)
        index, is_default = self.__get_buy_progress_index_cache(code)
        return index, is_default

    def set_traded_index(self, code, index):
    # 设置交易进度
    def set_traded_index(self, code, index, total_datas = None):
        last_info = self.latest_buy_progress_index_cache.get(code)
        # 交易进度是否改变
        traded_index_changed = False
        if not last_info or last_info[0] != index:
            if last_info and total_datas:
                val = total_datas[last_info[0]]['val']
                if time.time() - last_info[1] > 0:
                    rate = round(val["num"] * float(val["price"]) * 100 / (time.time() - last_info[1]))
                    # 成交速率
                    self.trade_speed_cache[code] = rate
            self.latest_buy_progress_index_cache[code] = (index, time.time())
            traded_index_changed = True
        self.__save_buy_progress_index(code, index, False)
        return traded_index_changed

    # 获取成交速率
    def get_trade_speed(self, code):
        return self.trade_speed_cache.get(code)


if __name__ == '__main__':