redis封装

Administrator

2023-08-02 a3c05bddc4c61d63b804ee541cf6dd01717ba94d

redis封装

 code_attribute/big_money_num_manager.py

@@ -4,6 +4,7 @@

# 大单管理
from db import redis_manager
from db.redis_manager import RedisUtils
from utils import tool

__redisManager = redis_manager.RedisManager(0)
@@ -25,7 +26,7 @@
# 设置过期时间
def expire(code):
    redis = __redisManager.getRedis()
    redis.expire("big_money-{}".format(code), tool.get_expire())
    RedisUtils.expire(redis, "big_money-{}".format(code), tool.get_expire())


def reset(code):
@@ -43,9 +44,9 @@

def reset_all():
    redis = __redisManager.getRedis()
    keys = redis.keys("big_money-*")
    keys = RedisUtils.keys(redis, "big_money-*")
    for k in keys:
        redis.setex(k, tool.get_expire(), 0)
        RedisUtils.setex(redis, k, tool.get_expire(), 0)


if __name__ == "__main__":

 code_attribute/code_data_util.py

@@ -8,6 +8,7 @@

from code_attribute import gpcode_manager
from db import mysql_data, redis_manager
from db.redis_manager import RedisUtils
from utils import tool

_redisManager = redis_manager.RedisManager(0)
@@ -31,14 +32,14 @@
    @classmethod
    def save(cls, code, val, unit):
        redis = _redisManager.getRedis()
        redis.setex("zyltgb-{}".format(code), tool.get_expire(),
        RedisUtils.setex(redis,"zyltgb-{}".format(code), tool.get_expire(),
                    round(float(val) * 100000000) if int(unit) == 0 else round(
                        float(val) * 10000))

    @classmethod
    def get(cls, code):
        redis = _redisManager.getRedis()
        val = redis.get("zyltgb-{}".format(code))
        val = RedisUtils.get(redis, "zyltgb-{}".format(code))
        if val is not None:
            return int(val)
        return None
@@ -67,6 +68,6 @@

if __name__ == "__main__":
    redis = _redisManager.getRedis()
    keys = redis.keys("zyltgb-*")
    keys = RedisUtils.keys(redis, "zyltgb-*")
    for key in keys:
        redis.delete(key)
        RedisUtils.delete(redis, key)

 code_attribute/code_nature_analyse.py

@@ -10,7 +10,7 @@

# 代码股性记录管理
from utils import tool
from db.redis_manager import RedisManager
from db.redis_manager import RedisManager, RedisUtils


class CodeNatureRecordManager:
@@ -25,7 +25,7 @@
    # 保存K线形态
    @classmethod
    def save_k_format(cls, code, k_format):
        cls.__get_redis().setex(f"k_format-{code}", tool.get_expire(), json.dumps(k_format))
        RedisUtils.setex(cls.__get_redis(),f"k_format-{code}", tool.get_expire(), json.dumps(k_format))

    @classmethod
    def get_k_format(cls, code):
@@ -49,7 +49,7 @@
    # 保存股性
    @classmethod
    def save_nature(cls, code, natures):
        cls.__get_redis().setex(f"code_nature-{code}", tool.get_expire(), json.dumps(natures))
        RedisUtils.setex(cls.__get_redis(),f"code_nature-{code}", tool.get_expire(), json.dumps(natures))

    @classmethod
    def get_nature(cls, code):

 code_attribute/code_volumn_manager.py

@@ -7,6 +7,7 @@
# yesterday 昨天的量
import json

from db.redis_manager import RedisUtils
from utils import global_util, tool
from db import redis_manager
from log_module.log import logger_day_volumn
@@ -19,8 +20,8 @@
    redis = __redis_manager.getRedis()
    global_util.max60_volumn[code] = (max60, max60_day)
    global_util.yesterday_volumn[code] = yesterday
    redis.setex("volumn_max60-{}".format(code), tool.get_expire(), json.dumps((max60, max60_day)))
    redis.setex("volumn_yes-{}".format(code), tool.get_expire(), yesterday)
    RedisUtils.setex(redis, "volumn_max60-{}".format(code), tool.get_expire(), json.dumps((max60, max60_day)))
    RedisUtils.setex(redis, "volumn_yes-{}".format(code), tool.get_expire(), yesterday)


# 获取历史量
@@ -42,7 +43,7 @@
    logger_day_volumn.info("code:{} volumn:{}".format(code, volumn))
    redis = __redis_manager.getRedis()
    global_util.today_volumn[code] = volumn
    redis.setex("volumn_today-{}".format(code), tool.get_expire(), volumn)
    RedisUtils.setex(redis, "volumn_today-{}".format(code), tool.get_expire(), volumn)


# 获取今日量
@@ -91,7 +92,7 @@
# 将量从数据库加入内存
def load():
    redis = __redis_manager.getRedis()
    keys = redis.keys("volumn_max60-*")
    keys = RedisUtils.keys(redis, "volumn_max60-*")
    if keys is not None:
        for k in keys:
            code = k.split("-")[1]
@@ -99,7 +100,7 @@
            if max60_volumn:
                max60_volumn = json.loads(max60_volumn)
            global_util.max60_volumn[code] = max60_volumn
    keys = redis.keys("volumn_yes-*")
    keys = RedisUtils.keys(redis, "volumn_yes-*")
    if keys is not None:
        for k in keys:
            code = k.split("-")[1]
@@ -107,4 +108,4 @@


if __name__ == "__main__":
    print(get_volume_rate("000059"))
    print(get_volume_rate("000059"))

 code_attribute/gpcode_first_screen_manager.py

@@ -5,6 +5,7 @@
# 设置首板未筛选的目标票
import json

from db.redis_manager import RedisUtils
from utils import tool
from db import redis_manager
from third_data import  block_info
@@ -23,11 +24,11 @@
# 4.最近炸开时间
# 5.是否已经涨停
def __save_first_code_data(code, data):
    __redisManager.getRedis().setex(f"first_code_data-{code}", tool.get_expire(), json.dumps(data))
    RedisUtils.setex(__redisManager.getRedis(),f"first_code_data-{code}", tool.get_expire(), json.dumps(data))


def __get_first_code_data(code):
    val = __get_redis().get(f"first_code_data-{code}")
    val = RedisUtils.get(__get_redis(), f"first_code_data-{code}")
    if val is None:
        return None
    return json.loads(val)
@@ -38,13 +39,13 @@
    redis = __redisManager.getRedis()
    if codes:
        for code in codes:
            redis.sadd("first_no_screen_codes", code)
        redis.expire("first_no_screen_codes", tool.get_expire())
            RedisUtils.sadd(redis, "first_no_screen_codes", code)
        RedisUtils.expire(redis, "first_no_screen_codes", tool.get_expire())


def clear_first_no_screen_codes():
    redis = __redisManager.getRedis()
    redis.delete("first_no_screen_codes")
    RedisUtils.delete(redis, "first_no_screen_codes")


def __remove_first_no_screen_codes(codes):
@@ -55,7 +56,7 @@


def __get_first_no_screen_codes():
    codes = __get_redis().smembers("first_no_screen_codes")
    codes = RedisUtils.smembers(__get_redis(), "first_no_screen_codes")
    if not codes:
        return set()
    return codes

 code_attribute/gpcode_manager.py

@@ -6,6 +6,7 @@

import constant
from db import redis_manager
from db.redis_manager import RedisUtils
from utils import tool
import decimal

@@ -36,7 +37,7 @@

    @classmethod
    def list_first_code_name_dict(cls):
        val = cls.__get_redis().get("gp_list_names_first")
        val = RedisUtils.get(cls.__get_redis(), "gp_list_names_first")
        if val is not None:
            val = json.loads(val)
            return val
@@ -44,7 +45,7 @@

    @classmethod
    def list_second_code_name_dict(cls):
        val = cls.__get_redis().get("gp_list_names")
        val = RedisUtils.get(cls.__get_redis(), "gp_list_names")
        if val is not None:
            val = json.loads(val)
            return val
@@ -52,7 +53,7 @@

    @classmethod
    def get_first_code_name(cls, code):
        val = cls.__get_redis().get("gp_list_names_first")
        val = RedisUtils.get(cls.__get_redis(), "gp_list_names_first")
        if not val:
            return None
        val = json.loads(val)
@@ -63,7 +64,7 @@

    @classmethod
    def get_second_code_name(cls, code):
        val = cls.__get_redis().get("gp_list_names")
        val = RedisUtils.get(cls.__get_redis(), "gp_list_names")
        if not val:
            return None
        val = json.loads(val)
@@ -73,7 +74,7 @@

    @classmethod
    def get_first_name_code(cls, name):
        val = cls.__get_redis().get("gp_list_names_first")
        val = RedisUtils.get(cls.__get_redis(), "gp_list_names_first")
        if not val:
            return None
        val = json.loads(val)
@@ -81,7 +82,7 @@

    @classmethod
    def add_first_code_name(cls, code, name):
        val = cls.__get_redis().get("gp_list_names_first")
        val = RedisUtils.get(cls.__get_redis(), "gp_list_names_first")
        if not val:
            return None
        val = json.loads(val)
@@ -90,7 +91,7 @@

    @classmethod
    def get_second_name_code(cls, name):
        val = cls.__get_redis().get("gp_list_names")
        val = RedisUtils.get(cls.__get_redis(), "gp_list_names")
        if not val:
            return None
        val = json.loads(val)
@@ -109,12 +110,12 @@
    # 删除首板代码名称
    @classmethod
    def clear_first_code_names(cls):
        cls.__get_redis().delete("gp_list_names_first")
        RedisUtils.delete(cls.__get_redis(), "gp_list_names_first")

    # 设置二板代码名称
    @classmethod
    def clear_second_code_names(cls):
        cls.__get_redis().delete("gp_list_names")
        RedisUtils.delete(cls.__get_redis(), "gp_list_names")


# 首板代码管理
@@ -129,8 +130,8 @@
    @classmethod
    def add_record(cls, codes):
        for code in codes:
            cls.__get_redis().sadd("first_code_record", code)
        cls.__get_redis().expire("first_code_record", tool.get_expire())
            RedisUtils.sadd(cls.__get_redis(), "first_code_record", code)
        RedisUtils.expire(cls.__get_redis(), "first_code_record", tool.get_expire())

    @classmethod
    def is_in_first_record(cls, code):
@@ -143,8 +144,8 @@
    @classmethod
    def add_limited_up_record(cls, codes):
        for code in codes:
            cls.__get_redis().sadd("first_code_limited_up_record", code)
        cls.__get_redis().expire("first_code_limited_up_record", tool.get_expire())
            RedisUtils.sadd(cls.__get_redis(), "first_code_limited_up_record", code)
        RedisUtils.expire(cls.__get_redis(), "first_code_limited_up_record", tool.get_expire())

    # 是否涨停过
    @classmethod
@@ -166,12 +167,12 @@

    @classmethod
    def clear(cls):
        cls.__get_redis().delete(cls.__redis_key)
        RedisUtils.delete(cls.__get_redis(), cls.__redis_key)

    @classmethod
    def add_code(cls, code):
        cls.__get_redis().sadd(cls.__redis_key, code)
        cls.__get_redis().expire(cls.__redis_key, tool.get_expire())
        RedisUtils.sadd(cls.__get_redis(), cls.__redis_key, code)
        RedisUtils.expire(cls.__get_redis(), cls.__redis_key, tool.get_expire())

    @classmethod
    def remove_code(cls, code):
@@ -183,7 +184,7 @@

    @classmethod
    def list_code(cls):
        return cls.__get_redis().smembers(cls.__redis_key)
        return RedisUtils.smembers(cls.__get_redis(), cls.__redis_key)


# 暂停下单代码管理
@@ -198,12 +199,12 @@

    @classmethod
    def clear(cls):
        cls.__get_redis().delete(cls.__redis_key)
        RedisUtils.delete(cls.__get_redis(), cls.__redis_key)

    @classmethod
    def add_code(cls, code):
        cls.__get_redis().sadd(cls.__redis_key, code)
        cls.__get_redis().expire(cls.__redis_key, tool.get_expire())
        RedisUtils.sadd(cls.__get_redis(), cls.__redis_key, code)
        RedisUtils.expire(cls.__get_redis(), cls.__redis_key, tool.get_expire())

    @classmethod
    def remove_code(cls, code):
@@ -215,7 +216,7 @@

    @classmethod
    def list_code(cls):
        return cls.__get_redis().smembers(cls.__redis_key)
        return RedisUtils.smembers(cls.__get_redis(), cls.__redis_key)


def __parse_codes_data(code_datas):
@@ -239,10 +240,10 @@
    codes, name_codes = __parse_codes_data(code_datas)
    redis_instance = __redisManager.getRedis()
    # 删除之前的
    redis_instance.delete("gp_list")
    RedisUtils.delete(redis_instance, "gp_list")
    CodesNameManager.clear_second_code_names()
    for d in codes:
        redis_instance.sadd("gp_list", d)
        RedisUtils.sadd(redis_instance, "gp_list", d)
    CodesNameManager.set_second_code_names(name_codes)


@@ -253,7 +254,7 @@
    redis_instance = __redisManager.getRedis()
    codes, name_codes = __parse_codes_data(code_datas)
    for d in codes:
        redis_instance.sadd("gp_list", d)
        RedisUtils.sadd(redis_instance, "gp_list", d)
    old_name_codes = CodesNameManager.list_second_code_name_dict()
    if old_name_codes is None:
        old_name_codes = name_codes
@@ -272,16 +273,16 @@
    codes_set = set()
    for code in codes:
        codes_set.add(code)
    old_codes_set = redis_instance.smembers("gp_list_first")
    old_codes_set = RedisUtils.smembers(redis_instance, "gp_list_first")
    if old_codes_set is None:
        old_codes_set = set()
    del_set = old_codes_set - codes_set
    add_codes = codes_set - old_codes_set
    for code in add_codes:
        redis_instance.sadd("gp_list_first", code)
        RedisUtils.sadd(redis_instance, "gp_list_first", code)
    for code in del_set:
        redis_instance.srem("gp_list_first", code)
    redis_instance.expire("gp_list_first", tool.get_expire())
    RedisUtils.expire(redis_instance, "gp_list_first", tool.get_expire())

    old_name_codes = CodesNameManager.list_first_code_name_dict()
    if old_name_codes is None:
@@ -302,7 +303,7 @@
# 获取首板代码
def get_first_gp_codes():
    redis_instance = __redisManager.getRedis()
    return redis_instance.smembers("gp_list_first")
    return RedisUtils.smembers(redis_instance, "gp_list_first")


# 是否在首板里面
@@ -349,17 +350,18 @@
    # 获取基本信息
    redis_instance = __redisManager.getRedis()
    # 删除之前的
    redis_instance.delete("gp_limit_up_list")
    RedisUtils.delete(redis_instance, "gp_limit_up_list")
    for d in gpset:
        redis_instance.sadd("gp_limit_up_list", json.dumps(d))
    redis_instance.expire("gp_limit_up_list", tool.get_expire())
    redis_instance.setex("gp_limit_up_list_update_time", tool.get_expire(), round(time.time() * 1000))
        RedisUtils.sadd(redis_instance, "gp_limit_up_list", json.dumps(d))
    RedisUtils.expire(redis_instance, "gp_limit_up_list", tool.get_expire())
    RedisUtils.setex(redis_instance, "gp_limit_up_list_update_time", tool.get_expire(), round(time.time() * 1000))


# 获取涨停列表
def get_limit_up_list():
    redis_instance = __redisManager.getRedis()
    return redis_instance.get("gp_limit_up_list_update_time"), redis_instance.smembers("gp_limit_up_list")
    return RedisUtils.get(redis_instance, "gp_limit_up_list_update_time"), RedisUtils.smembers(redis_instance,
                                                                                               "gp_limit_up_list")


def rm_gp(code):
@@ -375,7 +377,7 @@

def get_gp_list():
    redis_instance = __redisManager.getRedis()
    codes = redis_instance.smembers("gp_list")
    codes = RedisUtils.smembers(redis_instance, "gp_list")
    first_codes = get_first_gp_codes()
    return set.union(codes, first_codes)

@@ -383,7 +385,7 @@
# 获取二板代码
def get_second_gp_list():
    redis_instance = __redisManager.getRedis()
    codes = redis_instance.smembers("gp_list")
    codes = RedisUtils.smembers(redis_instance, "gp_list")
    return codes


@@ -402,7 +404,7 @@
# 获取收盘价
def get_price_pre(code):
    redis_instance = __redisManager.getRedis()
    result = redis_instance.get("price-pre-{}".format(code))
    result = RedisUtils.get(redis_instance, "price-pre-{}".format(code))
    if result is not None:
        return float(result)
    return None
@@ -427,7 +429,7 @@
    if code not in codes and not FirstCodeManager.is_in_first_record(code) and not force:
        return
    redis_instance = __redisManager.getRedis()
    redis_instance.setex("price-pre-{}".format(code), tool.get_expire(), str(price))
    RedisUtils.setex(redis_instance, "price-pre-{}".format(code), tool.get_expire(), str(price))


__limit_up_price_dict = {}
@@ -463,7 +465,7 @@
# 获取现价
def get_price(code):
    redis_instance = __redisManager.getRedis()
    result = redis_instance.get("price-{}".format(code))
    result = RedisUtils.get(redis_instance, "price-{}".format(code))
    if result is not None:
        return float(result)
    return None
@@ -472,16 +474,16 @@
# 设置现价
def set_price(code, price):
    redis_instance = __redisManager.getRedis()
    redis_instance.setex("price-{}".format(code), tool.get_expire(), price)
    RedisUtils.setex(redis_instance, "price-{}".format(code), tool.get_expire(), price)


# 获取正在监听的代码
def get_listen_codes():
    redis_instance = __redisManager.getRedis()
    keys = redis_instance.keys("listen_code-*-*")
    keys = RedisUtils.keys(redis_instance, "listen_code-*-*")
    codes = set()
    for k in keys:
        code = redis_instance.get(k)
        code = RedisUtils.get(redis_instance, k)
        if code is not None and len(code) > 0:
            codes.add(code)
    return codes
@@ -491,7 +493,7 @@
def get_listen_code_by_pos(client_id, pos):
    redis_instance = __redisManager.getRedis()
    key = "listen_code-{}-{}".format(client_id, pos)
    value = redis_instance.get(key)
    value = RedisUtils.get(redis_instance, key)
    # print("redis:", key,value)
    return value

@@ -499,7 +501,7 @@
# 设置位置的监听代码
def set_listen_code_by_pos(client_id, pos, code):
    redis_instance = __redisManager.getRedis()
    redis_instance.setex("listen_code-{}-{}".format(client_id, pos), tool.get_expire(), code)
    RedisUtils.setex(redis_instance, "listen_code-{}-{}".format(client_id, pos), tool.get_expire(), code)
    # 同步监听的代码集合
    __sync_listen_codes_pos()

@@ -508,12 +510,12 @@
def __sync_listen_codes_pos():
    redis_instance = __redisManager.getRedis()
    # 获取已经正在监听的代码
    keys = redis_instance.keys("code_listen_pos-*")
    keys = RedisUtils.keys(redis_instance, "code_listen_pos-*")
    codes_set = set()
    for key in keys:
        codes_set.add(key.replace("code_listen_pos-", ""))

    keys = redis_instance.keys("listen_code-*-*")
    keys = RedisUtils.keys(redis_instance, "listen_code-*-*")

    for key in keys:
        result = redis_instance.get(key)
@@ -524,15 +526,15 @@
            key_ = "code_listen_pos-{}".format(code_)
            val = redis_instance.get(key_)
            if val is None:
                redis_instance.setex(key_, tool.get_expire(), json.dumps((client_id_, pos_)))
                RedisUtils.setex(redis_instance, key_, tool.get_expire(), json.dumps((client_id_, pos_)))
            else:
                val = json.loads(val)
                if val[0] != client_id_ or val[1] != pos_:
                    redis_instance.setex(key_, tool.get_expire(), json.dumps((client_id_, pos_)))
                    RedisUtils.setex(redis_instance, key_, tool.get_expire(), json.dumps((client_id_, pos_)))

    # 移除没有监听的代码
    for code_ in codes_set:
        redis_instance.delete(code_)
        RedisUtils.delete(redis_instance, code_)


# 初始化位置
@@ -540,23 +542,23 @@
    redis_instance = __redisManager.getRedis()
    key = "listen_code-{}-{}".format(client_id, pos)
    redis_instance.setnx(key, "")
    redis_instance.expire(key, tool.get_expire())
    RedisUtils.expire(redis_instance, key, tool.get_expire())


# 清除所有监听代码
def clear_listen_codes():
    redis_instance = __redisManager.getRedis()
    keys = redis_instance.keys("listen_code-*-*")
    keys = RedisUtils.keys(redis_instance, "listen_code-*-*")
    for key in keys:
        redis_instance.setex(key, tool.get_expire(), "")
        RedisUtils.setex(redis_instance, key, tool.get_expire(), "")


def clear_first_codes():
    redis_instance = __redisManager.getRedis()
    redis_instance.delete("gp_list_first")
    redis_instance.delete("gp_list_names_first")
    redis_instance.delete("first_code_record")
    redis_instance.delete("first_code_limited_up_record")
    RedisUtils.delete(redis_instance, "gp_list_first")
    RedisUtils.delete(redis_instance, "gp_list_names_first")
    RedisUtils.delete(redis_instance, "first_code_record")
    RedisUtils.delete(redis_instance, "first_code_limited_up_record")


# 获取可以操作的位置
@@ -571,7 +573,7 @@
    for client_id in client_ids:
        redis_instance = __redisManager.getRedis()
        k = "listen_code-{}-*".format(client_id)
        keys = redis_instance.keys(k)
        keys = RedisUtils.keys(redis_instance, k)
        # random.shuffle(keys)
        codes = []
        for key in keys:
@@ -613,7 +615,7 @@
    for client_id in client_ids:
        redis_instance = __redisManager.getRedis()
        k = "listen_code-{}-*".format(client_id)
        keys = redis_instance.keys(k)
        keys = RedisUtils.keys(redis_instance, k)
        for key in keys:
            code = redis_instance.get(key)
            if not code:
@@ -670,27 +672,29 @@
# 设置正在操作的代码
def set_operate(code):
    redis_instance = __redisManager.getRedis()
    redis_instance.setex("gp_operate-{}".format(code), 30, "1")
    RedisUtils.setex(
        redis_instance, "gp_operate-{}".format(code), 30, "1")


# 批量设置正在操作的代码
def set_operates(codes):
    redis_instance = __redisManager.getRedis()
    for code in codes:
        redis_instance.setex("gp_operate-{}".format(code), 30, "1")
        RedisUtils.setex(
            redis_instance, "gp_operate-{}".format(code), 30, "1")


# 移除正在操作的代码
def rm_operate(code):
    redis_instance = __redisManager.getRedis()
    redis_instance.delete("gp_operate-{}".format(code))
    RedisUtils.delete(redis_instance, "gp_operate-{}".format(code))


# 批量移除正在操作的代码
def rm_operates(codes):
    redis_instance = __redisManager.getRedis()
    for code in codes:
        redis_instance.delete("gp_operate-{}".format(code))
        RedisUtils.delete(redis_instance, "gp_operate-{}".format(code))


if __name__ == '__main__':

 code_attribute/limit_up_time_manager.py

@@ -3,6 +3,7 @@
涨停时间管理器
"""
from db import redis_manager
from db.redis_manager import RedisUtils
from utils import global_util, tool

_redisManager = redis_manager.RedisManager(0)
@@ -12,7 +13,8 @@
    _time = get_limit_up_time(code)
    if _time is None:
        redis = _redisManager.getRedis()
        redis.setex("limit_up_time-{}".format(code), tool.get_expire(), time)
        RedisUtils.setex(
            redis, "limit_up_time-{}".format(code), tool.get_expire(), time)
        global_util.limit_up_time[code] = time


@@ -20,7 +22,7 @@
    time = global_util.limit_up_time.get(code)
    if time is None:
        redis = _redisManager.getRedis()
        time = redis.get("limit_up_time-{}".format(code))
        time = RedisUtils.get(redis, "limit_up_time-{}".format(code))
        if time is not None:
            global_util.limit_up_time[code] = time

@@ -29,11 +31,12 @@

def load_limit_up_time():
    redis = _redisManager.getRedis()
    keys = redis.keys("limit_up_time-*")
    keys = RedisUtils.keys(redis, "limit_up_time-*")
    for key in keys:
        code = key.replace("limit_up_time-", "")
        global_util.limit_up_time[code] = redis.get(key)
        global_util.limit_up_time[code] = RedisUtils.get(redis, key)


if __name__ == "__main__":
    list = [("1234578", "09:00:03",None), ("12345", "09:00:01",True), ("123456", "09:00:00",True), ("123457", "09:00:04",False)]
    list = [("1234578", "09:00:03", None), ("12345", "09:00:01", True), ("123456", "09:00:00", True),
            ("123457", "09:00:04", False)]

 db/redis_manager.py

@@ -26,12 +26,40 @@
        return redis.Redis(connection_pool=self.pool)


if __name__ == "__main__":
    _redisManager = RedisManager(0)
    redis = _redisManager.getRedis()
    keys = redis.keys("volumn_max60-*")
    for k in keys:
        # print(k)
        redis.delete(k)
class RedisUtils:

    @classmethod
    def get(cls, redis_, key):
        return redis_.get(key)

    @classmethod
    def delete(cls, redis_, key):
        return redis_.delete(key)

    @classmethod
    def keys(cls, redis_, key):
        return redis_.keys(key)

    @classmethod
    def set(cls, redis_, key, val):
        return redis_.set(key, val)

    @classmethod
    def setex(cls, redis_, key, expire, val):
        return redis_.setex(key, expire, val)

    @classmethod
    def expire(cls, redis_, key, expire):
        return redis_.expire(key, expire)

    @classmethod
    def sadd(cls, redis_, key, val):
        return redis_.sadd(key, val)

    @classmethod
    def smembers(cls, redis_, key):
        return redis_.smembers(key)


if __name__ == "__main__":
    pass

 gui.py

@@ -9,6 +9,7 @@

import win32gui

from db.redis_manager import RedisUtils
from utils import data_export_util
import multiprocessing

@@ -159,7 +160,7 @@
            try:
                redis = redis_manager.RedisManager().getRedis()
                redis.set("test", "1")
                redis.delete("test")
                RedisUtils.delete(redis, "test")
                text.insert(END, "redis连接成功！\n")
            except:
                error = "redis连接失败...\n"
@@ -220,7 +221,7 @@
    def __draw_pre_data_check(self, frame):
        def refresh_close_price_data():
            redis = redis_manager.RedisManager(0).getRedis()
            count = len(redis.keys("price-pre-*"))
            count = len(RedisUtils.keys(redis, "price-pre-*"))
            sv_num.set("获取到收盘价数量：{}".format(count))

        def re_get_close_price():
@@ -941,7 +942,7 @@

        def export_l2_data_origin(code):
            redis = redis_manager.RedisManager(1).getRedis()
            keys = redis.keys("big_data-{}-*".format(code))
            keys = RedisUtils.keys(redis, "big_data-{}-*".format(code))
            try:
                for k in keys:
                    datas = redis.get(k)

 inited_data.py

@@ -9,6 +9,7 @@
import gm.api as gmapi

from code_attribute import big_money_num_manager, global_data_loader, gpcode_manager, gpcode_first_screen_manager
from db.redis_manager import RedisUtils
from ths import client_manager
import constant
from utils import global_util, tool
@@ -35,16 +36,16 @@
# 设置账户信息
def setAccountInfo(accountId, strategyId, token):
    redis = redisManager.getRedis()
    redis.set("juejin-account-id", accountId)
    redis.set("juejin-strategy-id", strategyId)
    redis.set("juejin-token", token)
    RedisUtils.set(redis,"juejin-account-id", accountId)
    RedisUtils.set(redis,"juejin-strategy-id", strategyId)
    RedisUtils.set( redis, "juejin-token", token)


def getAccountInfo():
    redis = redisManager.getRedis()
    account_id = redis.get("juejin-account-id")
    strategy_id = redis.get("juejin-strategy-id")
    token = redis.get("juejin-token")
    account_id =RedisUtils.get( redis, "juejin-account-id")
    strategy_id = RedisUtils.get(redis, "juejin-strategy-id")
    token = RedisUtils.get(redis, "juejin-token")
    return account_id, strategy_id, token



 l2/cancel_buy_strategy.py

@@ -13,6 +13,7 @@
from code_attribute import big_money_num_manager, gpcode_manager
import l2_data_util
from db import redis_manager
from db.redis_manager import RedisUtils
from utils import tool
from l2.safe_count_manager import BuyL2SafeCountManager
from l2.transaction_progress import TradeBuyQueue
@@ -31,7 +32,7 @@
    __s_big_num_cancel_compute_data_cache = {}

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

    # 保存结束位置
@@ -40,12 +41,12 @@
        CodeDataCacheUtil.set_cache(cls.__s_big_num_cancel_compute_data_cache, code,
                                    (process_index, buy_num, cancel_num))
        key = "s_big_num_cancel_compute_data-{}".format(code)
        cls.__getRedis().setex(key, tool.get_expire(), json.dumps((process_index, buy_num, cancel_num)))
        RedisUtils.setex( cls.__get_redis(),key, tool.get_expire(), json.dumps((process_index, buy_num, cancel_num)))

    @classmethod
    def __get_compute_data(cls, code):
        key = "s_big_num_cancel_compute_data-{}".format(code)
        val = cls.__getRedis().get(key)
        val = RedisUtils.get(cls.__get_redis(), key)
        if val is None:
            return -1, 0, 0
        val = json.loads(val)
@@ -65,13 +66,13 @@
        CodeDataCacheUtil.clear_cache(cls.__s_big_num_cancel_compute_data_cache, code)
        ks = ["s_big_num_cancel_compute_data-{}".format(code)]
        for key in ks:
            cls.__getRedis().delete(key)
            RedisUtils.delete(cls.__get_redis(), key)

    @classmethod
    def clear_data(cls):
        ks = ["s_big_num_cancel_compute_data-*"]
        for key in ks:
            keys = cls.__getRedis().keys(key)
            keys = RedisUtils.keys(cls.__get_redis(), key)
            for k in keys:
                code = k.replace("s_big_num_cancel_compute_data-","")
                cls.__clear_data(code)
@@ -260,7 +261,7 @@
    __cancel_compute_data_cache = {}

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

    # 保存成交位置到执行位置的揽括范围数据
@@ -268,13 +269,13 @@
    def __save_watch_index_set(cls, code, datas, process_index, finish):
        CodeDataCacheUtil.set_cache(cls.__cancel_watch_indexs_cache, code, (list(datas), process_index, finish))
        key = f"h_cancel_watch_indexs-{code}"
        cls.__getRedis().setex(key, tool.get_expire(), json.dumps((list(datas), process_index, finish)))
        RedisUtils.setex(cls.__get_redis(),key, tool.get_expire(), json.dumps((list(datas), process_index, finish)))

    # 保存成交进度
    @classmethod
    def __get_watch_index_set(cls, code):
        key = f"h_cancel_watch_indexs-{code}"
        val = cls.__getRedis().get(key)
        val = RedisUtils.get(cls.__get_redis(), key)
        if val is None:
            return None, -1, False
        val = json.loads(val)
@@ -295,14 +296,14 @@
        CodeDataCacheUtil.set_cache(cls.__cancel_watch_indexs_exec_cache, code,
                                    (list(datas), process_index, total_count, big_num_count, finished))
        key = f"h_cancel_watch_indexs_exec-{code}"
        cls.__getRedis().setex(key, tool.get_expire(),
        RedisUtils.setex( cls.__get_redis(),key, tool.get_expire(),
                               json.dumps((list(datas), process_index, total_count, big_num_count, finished)))

    # 保存成交进度
    @classmethod
    def __get_watch_index_set_after_exec(cls, code):
        key = f"h_cancel_watch_indexs_exec-{code}"
        val = cls.__getRedis().get(key)
        val = RedisUtils.get(cls.__get_redis(), key)
        if val is None:
            return [], -1, 0, 0, False
        val = json.loads(val)
@@ -322,13 +323,13 @@
    def __add_watch_canceled_index(cls, code, index):
        CodeDataCacheUtil.clear_cache(cls.__cancel_watch_canceled_indexs_cache, code)
        key = f"h_cancel_watch_canceled_indexs-{code}"
        cls.__getRedis().sadd(key, index)
        cls.__getRedis().expire(key, tool.get_expire())
        RedisUtils.sadd(cls.__get_redis(), key, index)
        RedisUtils.expire(cls.__get_redis(), key, tool.get_expire())

    @classmethod
    def __get_watch_canceled_index(cls, code):
        key = f"h_cancel_watch_canceled_indexs-{code}"
        return cls.__getRedis().smembers(key)
        return RedisUtils.smembers(cls.__get_redis(), key)

    @classmethod
    def __get_watch_canceled_index_cache(cls, code):
@@ -343,7 +344,7 @@
    def __del_watch_canceled_index(cls, code):
        CodeDataCacheUtil.clear_cache(cls.__cancel_watch_canceled_indexs_cache, code)
        key = f"h_cancel_watch_canceled_indexs-{code}"
        cls.__getRedis().delete(key)
        RedisUtils.delete( cls.__get_redis(), key)

    # 保存成交进度
    @classmethod
@@ -351,12 +352,12 @@
        CodeDataCacheUtil.set_cache(cls.__cancel_traded_progress_cache, code,
                                    (origin_process_index, latest_process_index))
        key = "h_cancel_traded_progress-{}".format(code)
        cls.__getRedis().setex(key, tool.get_expire(), json.dumps((origin_process_index, latest_process_index)))
        RedisUtils.setex(cls.__get_redis(),key, tool.get_expire(), json.dumps((origin_process_index, latest_process_index)))

    @classmethod
    def __get_traded_progress(cls, code):
        key = "h_cancel_traded_progress-{}".format(code)
        val = cls.__getRedis().get(key)
        val = RedisUtils.get(cls.__get_redis(), key)
        if val is None:
            return None, None
        val = json.loads(val)
@@ -377,12 +378,12 @@
        CodeDataCacheUtil.set_cache(cls.__cancel_compute_data_cache, code,
                                    (process_index, cancel_num))
        key = "h_cancel_compute_data-{}".format(code)
        cls.__getRedis().setex(key, tool.get_expire(), json.dumps((process_index, cancel_num)))
        RedisUtils.setex(cls.__get_redis(),key, tool.get_expire(), json.dumps((process_index, cancel_num)))

    @classmethod
    def __get_compute_data(cls, code):
        key = "h_cancel_compute_data-{}".format(code)
        val = cls.__getRedis().get(key)
        val = RedisUtils.get(cls.__get_redis(), key)
        if val is None:
            return -1, 0
        val = json.loads(val)
@@ -401,7 +402,7 @@
    def __del_compute_data(cls, code):
        CodeDataCacheUtil.clear_cache(cls.__cancel_compute_data_cache, code)
        key = "h_cancel_compute_data-{}".format(code)
        cls.__getRedis().delete(key)
        RedisUtils.delete(cls.__get_redis(), key)

    @classmethod
    def __clear_data(cls, code):
@@ -416,7 +417,7 @@
              f"h_cancel_watch_indexs-{code}", f"h_cancel_traded_progress-{code}",
              f"h_cancel_watch_canceled_indexs-{code}"]
        for key in ks:
            cls.__getRedis().delete(key)
            RedisUtils.delete(cls.__get_redis(), key)

    @classmethod
    def need_cancel(cls, code, buy_single_index, buy_exec_index, start_index, end_index, total_data,
@@ -748,17 +749,17 @@
    __cancel_real_order_index_cache = {}

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

    @classmethod
    def __set_real_order_index(cls, code, index):
        CodeDataCacheUtil.set_cache(cls.__cancel_real_order_index_cache, code, index)
        cls.__getRedis().setex(f"d_cancel_real_order_index-{code}", tool.get_expire(), f"{index}")
        RedisUtils.setex(cls.__get_redis(),f"d_cancel_real_order_index-{code}", tool.get_expire(), f"{index}")

    @classmethod
    def __get_real_order_index(cls, code):
        val = cls.__getRedis().get(f"d_cancel_real_order_index-{code}")
        val = cls.__get_redis().get(f"d_cancel_real_order_index-{code}")
        if val:
            return int(val)
        return None
@@ -775,14 +776,14 @@
    @classmethod
    def clear(cls, code=None):
        if code:
            cls.__getRedis().delete(f"d_cancel_real_order_index-{code}")
            RedisUtils.delete( cls.__get_redis(), f"d_cancel_real_order_index-{code}")
        else:
            keys = cls.__getRedis().keys("d_cancel_real_order_index-*")
            keys = RedisUtils.keys(cls.__get_redis(), "d_cancel_real_order_index-*")
            if keys:
                for k in keys:
                    code = k.replace("d_cancel_real_order_index-", "")
                    CodeDataCacheUtil.clear_cache(cls.__cancel_real_order_index_cache, code)
                    cls.__getRedis().delete(k)
                    RedisUtils.delete(cls.__get_redis(), k)

    # 设置成交位
    @classmethod
@@ -842,23 +843,23 @@
    __cancel_watch_index_cache = {}

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

    @classmethod
    def __add_watch_index(cls, code, index):
        CodeDataCacheUtil.clear_cache(cls.__cancel_watch_index_cache, code)
        cls.__getRedis().sadd(f"l_cancel_watch_index-{code}", index)
        cls.__getRedis().expire(f"l_cancel_watch_index-{code}", tool.get_expire())
        RedisUtils.sadd(cls.__get_redis(), f"l_cancel_watch_index-{code}", index)
        cls.__get_redis().expire(f"l_cancel_watch_index-{code}", tool.get_expire())

    @classmethod
    def __del_watch_index(cls, code, index):
        CodeDataCacheUtil.clear_cache(cls.__cancel_watch_index_cache, code)
        cls.__getRedis().srem(f"l_cancel_watch_index-{code}", index)
        cls.__get_redis().srem(f"l_cancel_watch_index-{code}", index)

    @classmethod
    def __get_watch_indexes(cls, code):
        return cls.__getRedis().smembers(f"l_cancel_watch_index-{code}")
        return RedisUtils.smembers(cls.__get_redis(), f"l_cancel_watch_index-{code}")

    @classmethod
    def __get_watch_indexes_cache(cls, code):
@@ -873,14 +874,14 @@
    @classmethod
    def del_watch_index(cls, code):
        CodeDataCacheUtil.clear_cache(cls.__cancel_watch_index_cache, code)
        cls.__getRedis().delete(f"l_cancel_watch_index-{code}")
        RedisUtils.delete(cls.__get_redis(), f"l_cancel_watch_index-{code}")

    @classmethod
    def clear(cls, code=None):
        if code:
            cls.del_watch_index(code)
        else:
            keys = cls.__getRedis().keys(f"l_cancel_watch_index-*")
            keys = RedisUtils.keys(cls.__get_redis(), f"l_cancel_watch_index-*")
            for k in keys:
                code = k.replace("l_cancel_watch_index-", "")
                cls.del_watch_index(code)
@@ -1002,7 +1003,7 @@

        key = "l2_limit_up_second_money-{}-{}".format(code, time.replace(":", ""))

        cls.__get_redis().setex(key, tool.get_expire(), json.dumps((old_num, old_from, old_to)))
        RedisUtils.setex(cls.__get_redis(),key, tool.get_expire(), json.dumps((old_num, old_from, old_to)))

    @classmethod
    def __get_l2_second_money_record(cls, code, time):
@@ -1020,14 +1021,14 @@
    @classmethod
    def __get_l2_second_money_record_keys(cls, code, time_regex):
        key = "l2_limit_up_second_money-{}-{}".format(code, time_regex)
        keys = cls.__get_redis().keys(key)
        keys = RedisUtils.keys(cls.__get_redis(), key)
        return keys

    # 设置l2最新的封单额数据
    @classmethod
    def __set_l2_latest_money_record(cls, code, index, num):
        key = "l2_limit_up_money-{}".format(code)
        cls.__get_redis().setex(key, tool.get_expire(), json.dumps((num, index)))
        RedisUtils.setex(cls.__get_redis(),key, tool.get_expire(), json.dumps((num, index)))

    # 返回数量,索引
    @classmethod
@@ -1143,7 +1144,7 @@
    @classmethod
    def clear(cls, code):
        key = "l2_limit_up_money-{}".format(code)
        cls.__get_redis().delete(key)
        RedisUtils.delete(cls.__get_redis(), key)

    # 返回取消的标志数据
    # with_cancel 是否需要判断是否撤销
@@ -1351,7 +1352,7 @@
    @classmethod
    def __save_process_index(cls, code, index):
        key = "limit_up_sell_index-{}".format(code)
        cls.__get_redis().setex(key, tool.get_expire(), index)
        RedisUtils.setex( cls.__get_redis(),key, tool.get_expire(), index)

    @classmethod
    def __get_process_index(cls, code):
@@ -1365,15 +1366,15 @@
    @classmethod
    def delete(cls, code):
        key = "limit_up_sell_num-{}".format(code)
        cls.__get_redis().delete(key)
        RedisUtils.delete( cls.__get_redis(), key)
        key = "limit_up_sell_index-{}".format(code)
        cls.__get_redis().delete(key)
        RedisUtils.delete( cls.__get_redis(), key)

    @classmethod
    def clear(cls):
        keys = cls.__get_redis().keys("limit_up_sell_num-*")
        keys = RedisUtils.keys(cls.__get_redis(), "limit_up_sell_num-*")
        for k in keys:
            cls.__get_redis().delete(k)
            RedisUtils.delete(cls.__get_redis(), k)

    # 处理数据，返回是否需要撤单
    # 处理范围：买入执行位-当前最新位置

 l2/code_price_manager.py

@@ -3,6 +3,7 @@
"""
import json

from db.redis_manager import RedisUtils
from utils import tool
from db import redis_manager
from log_module.log import logger_trade_queue_price_info
@@ -20,7 +21,7 @@
    # 保存买1价格信息
    @classmethod
    def __save_buy1_price_info(cls, code, limit_up_time, open_limit_up_time):
        cls.__get_redis().setex(f"buy1_price_limit_up_info-{code}", tool.get_expire(),
        RedisUtils.setex(cls.__get_redis(),f"buy1_price_limit_up_info-{code}", tool.get_expire(),
                                json.dumps((limit_up_time, open_limit_up_time)))

    @classmethod
@@ -34,7 +35,7 @@
    @classmethod
    def __save_buy1_price(cls, code, buy_1_price):
        cls.__current_buy_1_price[code] = buy_1_price
        cls.__get_redis().setex(f"buy1_price-{code}", tool.get_expire(), buy_1_price)
        RedisUtils.setex(cls.__get_redis(),f"buy1_price-{code}", tool.get_expire(), buy_1_price)

    @classmethod
    def __get_buy1_price(cls, code):
@@ -43,7 +44,7 @@
    # 设置炸板后的最低价
    @classmethod
    def __save_open_limit_up_lowest_price(cls, code, price):
        cls.__get_redis().setex(f"open_limit_up_lowest_price-{code}", tool.get_expire(), f"{price}")
        RedisUtils.setex(cls.__get_redis(),f"open_limit_up_lowest_price-{code}", tool.get_expire(), f"{price}")

    @classmethod
    def __get_open_limit_up_lowest_price(cls, code):

 l2/l2_data_manager.py

@@ -4,6 +4,7 @@
import json

from db import redis_manager
from db.redis_manager import RedisUtils
from utils import tool
from log_module.log import logger_l2_trade_buy
from utils.tool import CodeDataCacheUtil
@@ -42,7 +43,7 @@
    def delete_buy_point(code):
        CodeDataCacheUtil.clear_cache(TradePointManager.__buy_compute_index_info_cache, code)
        redis = TradePointManager.__get_redis()
        redis.delete("buy_compute_index_info-{}".format(code))
        RedisUtils.delete(redis, "buy_compute_index_info-{}".format(code))

    # 获取买入点信息
    # 返回数据为：买入点 累计纯买额 已经计算的数据索引
@@ -87,7 +88,8 @@
            data_ = (_buy_single_index, buy_exec_index, compute_index, nums, count, list(max_num_sets),
                     volume_rate)
        CodeDataCacheUtil.set_cache(TradePointManager.__buy_compute_index_info_cache, code, data_)
        redis.setex(_key, expire,
        RedisUtils.setex(
            redis,_key, expire,
                    json.dumps(data_))

    # 获取撤买入开始计算的信息
@@ -108,20 +110,20 @@
    def set_buy_cancel_single_pos(cls, code, index):
        redis = TradePointManager.__get_redis()
        expire = tool.get_expire()
        redis.setex("buy_cancel_single_pos-{}".format(code), expire, index)
        RedisUtils.setex(redis,"buy_cancel_single_pos-{}".format(code), expire, index)

    # 删除买撤点数据
    @classmethod
    def delete_buy_cancel_point(cls, code):
        redis = TradePointManager.__get_redis()
        redis.delete("buy_cancel_single_pos-{}".format(code))
        RedisUtils.delete( redis, "buy_cancel_single_pos-{}".format(code))

    # 设置买撤纯买额
    @classmethod
    def set_compute_info_for_cancel_buy(cls, code, index, nums):
        redis = TradePointManager.__get_redis()
        expire = tool.get_expire()
        redis.setex("compute_info_for_cancel_buy-{}".format(code), expire, json.dumps((index, nums)))
        RedisUtils.setex( redis,"compute_info_for_cancel_buy-{}".format(code), expire, json.dumps((index, nums)))
        logger_l2_trade_buy.info("{}保存撤单纯买额信息：{}，{}", code, index, nums)

    # 获取买撤纯买额计算信息
@@ -138,14 +140,14 @@
    @classmethod
    def delete_compute_info_for_cancel_buy(cls, code):
        redis = TradePointManager.__get_redis()
        redis.delete("compute_info_for_cancel_buy-{}".format(code))
        RedisUtils.delete(redis, "compute_info_for_cancel_buy-{}".format(code))

    # 从买入信号开始设置涨停买与涨停撤的单数
    @classmethod
    def set_count_info_for_cancel_buy(cls, code, index, buy_count, cancel_count):
        redis = TradePointManager.__get_redis()
        expire = tool.get_expire()
        redis.setex("count_info_for_cancel_buy-{}".format(code), expire, json.dumps((index, buy_count, cancel_count)))
        RedisUtils.setex(redis,"count_info_for_cancel_buy-{}".format(code), expire, json.dumps((index, buy_count, cancel_count)))
        logger_l2_trade_buy.info("{}保存撤单纯买额信息：{}，{}", code, index, buy_count, cancel_count)

    # 获取买撤纯买额计算信息
@@ -162,17 +164,17 @@
    @classmethod
    def delete_count_info_for_cancel_buy(cls, code):
        redis = TradePointManager.__get_redis()
        redis.delete("count_info_for_cancel_buy-{}".format(code))
        RedisUtils.delete(redis, "count_info_for_cancel_buy-{}".format(code))


# 清除l2数据
def clear_l2_data(code):
    redis_l2 = redis_manager.RedisManager(1).getRedis()
    keys = redis_l2.keys("l2-{}-*".format(code))
    keys = RedisUtils.keys( redis_l2, "l2-{}-*".format(code))
    for k in keys:
        redis_l2.delete(k)
        RedisUtils.delete(redis_l2,k)

    redis_l2.delete("l2-data-latest-{}".format(code))
    RedisUtils.delete(redis_l2, "l2-data-latest-{}".format(code))


second_930 = 9 * 3600 + 30 * 60 + 0
@@ -184,9 +186,9 @@
    redis = _redisManager.getRedis()
    count = redis.scard(key)
    if count > 0:
        redis.delete(key)
    redis.sadd(key, "000000")
    redis.expire(key, tool.get_expire())
        RedisUtils.delete(redis, key)
    RedisUtils.sadd(redis, key, "000000")
    RedisUtils.expire(redis, key, tool.get_expire())


# 移除l2固定监控代码
@@ -200,8 +202,8 @@
def add_to_l2_fixed_codes(code):
    key = "l2-fixed-codes"
    redis = _redisManager.getRedis()
    redis.sadd(key, code)
    redis.expire(key, tool.get_expire())
    RedisUtils.sadd(redis, key, code)
    RedisUtils.expire(redis, key, tool.get_expire())


# 是否在l2固定监控代码中

 l2/l2_data_manager_new.py

@@ -5,6 +5,7 @@
from code_attribute import big_money_num_manager, code_volumn_manager, code_data_util, industry_codes_sort, \
    limit_up_time_manager, global_data_loader, gpcode_manager
import constant
from db.redis_manager import RedisUtils
from l2.huaxin import l2_huaxin_util, huaxin_delegate_postion_manager
from third_data import kpl_data_manager, block_info
from utils import global_util, ths_industry_util, tool
@@ -69,12 +70,12 @@
        if self.__get_begin_pos(code) is None:
            # 保存位置
            key = "m_big_money_begin-{}".format(code)
            self.__get_redis().setex(key, tool.get_expire(), index)
            RedisUtils.setex( self.__get_redis(), key, tool.get_expire(), index)

    # 获取计算开始位置
    def __get_begin_pos(self, code):
        key = "m_big_money_begin-{}".format(code)
        val = self.__get_redis().get(key)
        val = RedisUtils.get(self.__get_redis(),key)
        if val is None:
            return None
        return int(val)
@@ -82,17 +83,17 @@
    # 清除已经处理的数据
    def clear_processed_end_index(self, code):
        key = "m_big_money_process_index-{}".format(code)
        self.__get_redis().delete(key)
        RedisUtils.delete(self.__get_redis(), key)

    # 添加已经处理过的单
    def __set_processed_end_index(self, code, index):
        key = "m_big_money_process_index-{}".format(code)
        self.__get_redis().setex(key, tool.get_expire(), index)
        RedisUtils.setex(self.__get_redis(), key, tool.get_expire(), index)

    # 是否已经处理过
    def __get_processed_end_index(self, code):
        key = "m_big_money_process_index-{}".format(code)
        val = self.__get_redis().get(key)
        val = RedisUtils.get(self.__get_redis(), key)
        if val is None:
            return None
        return int(val)

 l2/l2_data_util.py

@@ -13,6 +13,7 @@

import constant
from code_attribute import gpcode_manager
from db.redis_manager import RedisUtils
from l2 import l2_data_log, l2_data_source_util
from log_module import log
from db import redis_manager
@@ -38,7 +39,7 @@
    if load_latest :
        if local_latest_datas.get(code) is None or force:
            # 获取最近的数据
            _data = redis.get("l2-data-latest-{}".format(code))
            _data = RedisUtils.get(redis,"l2-data-latest-{}".format(code))
            if _data is not None:
                if code in local_latest_datas:
                    local_latest_datas[code] = json.loads(_data)
@@ -125,21 +126,21 @@
            for _data in datas:
                i += 1
                key = "l2-" + _data["key"]
                value = redis_instance.get(key)
                value = RedisUtils.get(redis_instance, key)
                if value is None:
                    # 新增
                    try:
                        value = {"index": _data["index"], "re": _data["re"]}
                        redis_instance.setex(key, expire, json.dumps(value))
                        RedisUtils.setex(redis_instance,key, expire, json.dumps(value))
                    except:
                        logging.error("更正L2数据出错：{} key:{}".format(code, key))
                else:
                    json_value = json.loads(value)
                    if json_value["re"] != _data["re"]:
                        json_value["re"] = _data["re"]
                        redis_instance.setex(key, expire, json.dumps(json_value))
                        RedisUtils.setex(redis_instance,key, expire, json.dumps(json_value))
    finally:
        redis_instance.delete("l2-save-{}".format(code))
        RedisUtils.delete(redis_instance, "l2-save-{}".format(code))

    print("保存新数据用时：", msg, "耗时：{}".format(round(time.time() * 1000) - start_time))
    return datas
@@ -153,7 +154,7 @@
        # 保存最近的数据
        __start_time = round(time.time() * 1000)
        if datas:
            redis.setex("l2-data-latest-{}".format(code), tool.get_expire(), json.dumps(datas))
            RedisUtils.setex(redis,"l2-data-latest-{}".format(code), tool.get_expire(), json.dumps(datas))
            l2_data_log.l2_time(code, round(time.time() * 1000) - __start_time, "保存最近l2数据用时")
            # 设置进内存
            local_latest_datas[code] = datas
@@ -170,7 +171,7 @@
def set_l2_data_latest_count(code, count):
    redis = _redisManager.getRedis()
    key = "latest-l2-count-{}".format(code)
    redis.setex(key, 2, count)
    RedisUtils.setex( redis,key, 2, count)
    pass


@@ -181,7 +182,7 @@
    redis = _redisManager.getRedis()
    key = "latest-l2-count-{}".format(code)

    result = redis.get(key)
    result = RedisUtils.get(redis, key)
    if result is None:
        return 0
    else:

 l2/safe_count_manager.py

@@ -4,6 +4,7 @@
# 下单L2的安全笔数管理
import json

from db.redis_manager import RedisUtils
from l2 import l2_data_source_util
from trade import l2_trade_factor
from db import redis_manager
@@ -23,13 +24,13 @@
    # 记录每一次的处理进度
    def __save_compute_progress(self, code, last_buy_single_index, process_index, buy_num, cancel_num):
        key = "safe_count_l2-{}-{}".format(code, last_buy_single_index)
        self.__getRedis().setex(key, tool.get_expire(),
                                json.dumps((last_buy_single_index, process_index, buy_num, cancel_num)))
        RedisUtils.setex(self.__getRedis(), key, tool.get_expire(),
                         json.dumps((last_buy_single_index, process_index, buy_num, cancel_num)))

    # 返回数据与更新时间
    def __get_compute_progress(self, code, last_buy_single_index):
        key = "safe_count_l2-{}-{}".format(code, last_buy_single_index)
        val = self.__getRedis().get(key)
        val = RedisUtils.get( self.__getRedis(), key)
        if val is None:
            return None, -1, 0, 0
        val = json.loads(val)
@@ -38,11 +39,11 @@
    # 保存最近的下单信息
    def __save_latest_place_order_info(self, code, buy_single_index, buy_exec_index, cancel_index):
        key = "latest_place_order_info-{}".format(code)
        self.__getRedis().setex(key, tool.get_expire(), json.dumps((buy_single_index, buy_exec_index, cancel_index)))
        RedisUtils.setex( self.__getRedis(), key, tool.get_expire(), json.dumps((buy_single_index, buy_exec_index, cancel_index)))

    def __get_latest_place_order_info(self, code):
        key = "latest_place_order_info-{}".format(code)
        val = self.__getRedis().get(key)
        val = RedisUtils.get(self.__getRedis(), key)
        if val is None:
            return None, None, None
        val = json.loads(val)
@@ -50,22 +51,23 @@

    def __get_all_compute_progress(self, code):
        key_regex = f"safe_count_l2-{code}-*"
        keys = self.__getRedis().keys(key_regex)
        keys = RedisUtils.keys(self.__getRedis(), key_regex)
        vals = []
        for k in keys:
            val = self.__getRedis().get(k)
            val = RedisUtils.get(self.__getRedis(), k)
            val = json.loads(val)
            vals.append(val)
        return vals

    def clear_data(self, code):
        key_regex = f"safe_count_l2-{code}-*"
        keys = self.__getRedis().keys(key_regex)
        keys = RedisUtils.keys(self.__getRedis(), key_regex)
        for k in keys:
            self.__getRedis().delete(k)
            RedisUtils.delete(self.__getRedis(),k)

        key = f"latest_place_order_info-{code}"
        self.__getRedis().delete(key)
        RedisUtils.delete(
            self.__getRedis(),key)

    # 获取基础的安全笔数
    def __get_base_save_count(self, code, is_first):

 l2/transaction_progress.py

@@ -8,6 +8,7 @@

import constant
from db import redis_manager
from db.redis_manager import RedisUtils
from utils import tool
import l2.l2_data_util
from log_module.log import logger_l2_trade_buy_queue, logger_l2_trade_buy_progress
@@ -24,7 +25,7 @@

    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.__getRedis(), key, tool.get_expire(), json.dumps((num_list, tool.get_now_time_str())))

    # 返回数据与更新时间
    def __get_buy_queue_data(self, code):
@@ -37,7 +38,7 @@

    def __save_buy_progress_index(self, 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(self.__getRedis(), key, tool.get_expire(), json.dumps((index, is_default)))
        # 返回数据与更新时间

    def __get_buy_progress_index(self, code):
@@ -51,7 +52,7 @@
    # 最近的非涨停买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.__getRedis(), key, tool.get_expire(), time_str)

    def __get_latest_not_limit_up_time(self, code):
        key = "latest_not_limit_up_time-{}".format(code)

 l2_data_util.py

@@ -6,6 +6,8 @@
# 比较时间的大小
import json
import time

from db.redis_manager import RedisUtils
from utils.tool import async_call

from l2 import l2_data_manager
@@ -40,6 +42,7 @@
            return True
        else:
            return False


# 获取大资金的金额
def get_big_money_val(limit_up_price):
@@ -177,7 +180,8 @@
            continue
        if same_time_nums[time_] > 20:
            redis = l2_data_manager._redisManager.getRedis()
            redis.setex("big_data-{}-{}".format(code, int(round(time.time() * 1000))), tool.get_expire(), d1)
            RedisUtils.setex(redis, "big_data-{}-{}".format(code, int(round(time.time() * 1000))), tool.get_expire(),
                             d1)
            break


@@ -186,7 +190,7 @@
# @async_call
def save_l2_latest_data_number(code, num):
    redis = l2_data_manager._redisManager.getRedis()
    redis.setex("l2_latest_data_num-{}".format(code), 3, num)
    RedisUtils.setex(redis, "l2_latest_data_num-{}".format(code), 3, num)


# 获取最新数据条数

 output/limit_up_data_filter.py

@@ -5,6 +5,7 @@
# 判断是龙几，判断是否涨停，判断是否炸板，加载分数

from code_attribute import code_volumn_manager, limit_up_time_manager, gpcode_manager
from db.redis_manager import RedisUtils
from utils import tool
from db import redis_manager
from third_data.kpl_data_manager import KPLDataManager
@@ -22,11 +23,11 @@
        return self.__redisManager.getRedis()

    def ignore_code(self, type, code):
        self.__get_redis().sadd(f"kp_ignore_codes_{type}", code)
        self.__get_redis().expire(f"kp_ignore_codes_{type}", tool.get_expire())
        RedisUtils.sadd(self.__get_redis(), f"kp_ignore_codes_{type}", code)
        RedisUtils.expire( self.__get_redis(), f"kp_ignore_codes_{type}", tool.get_expire())

    def list_ignore_codes(self, type):
        return self.__get_redis().smembers(f"kp_ignore_codes_{type}")
        return RedisUtils.smembers(self.__get_redis(), f"kp_ignore_codes_{type}")


# 获取涨停顺序（按涨停原因分组）

 test/l2_trade_test.py

@@ -9,6 +9,7 @@
from unittest import mock

from code_attribute import big_money_num_manager, gpcode_manager
from db.redis_manager import RedisUtils
from log_module import log
from utils import tool
from db import redis_manager
@@ -27,20 +28,20 @@
    redis_l2 = redis_manager.RedisManager(1).getRedis()
    keys = ["buy1_volumn_latest_info-{}", "m_big_money_begin-{}", "m_big_money_process_index-{}"]
    for k in keys:
        redis_l2.delete(k.format(code))
        RedisUtils.delete(redis_l2, k.format(code))
    l2.l2_data_manager.TradePointManager.delete_buy_point(code)
    big_money_num_manager.reset(code)
    redis_trade = redis_manager.RedisManager(2).getRedis()
    redis_trade.delete("trade-state-{}".format(code))
    RedisUtils.delete( redis_trade, "trade-state-{}".format(code))
    trade_data_manager.placeordercountmanager.clear_place_order_count(code)
    redis_info = redis_manager.RedisManager(0).getRedis()
    keys = redis_info.keys("*{}*".format(code))
    keys = RedisUtils.keys(redis_info, "*{}*".format(code))
    for k in keys:
        if k.find("pre") is not None:
            continue
        if k.find("zyltgb") is not None:
            continue
        redis_info.delete(k)
        RedisUtils.delete(redis_info, k)
    BuyL2SafeCountManager().clear_data(code)

    transaction_progress.TradeBuyQueue().set_traded_index(code, 0)

 third_data/code_plate_key_manager.py

@@ -6,6 +6,7 @@
import json

import constant
from db.redis_manager import RedisUtils
from third_data import kpl_block_util
from utils import global_util, tool
from log_module import log
@@ -28,14 +29,14 @@
        if blocks is None:
            return
        # 保存前2条数据
        self.__get_redis().setex(f"kpl_jx_blocks-{code}", tool.get_expire(), json.dumps(blocks))
        RedisUtils.setex(self.__get_redis(),f"kpl_jx_blocks-{code}", tool.get_expire(), json.dumps(blocks))
        self.__code_blocks[code] = blocks

    # 获取精选板块
    def get_jx_blocks(self, code):
        if code in self.__code_blocks:
            return self.__code_blocks[code]
        val = self.__get_redis().get(f"kpl_jx_blocks-{code}")
        val = RedisUtils.get(self.__get_redis(), f"kpl_jx_blocks-{code}")
        if val is None:
            return None
        else:
@@ -52,11 +53,11 @@
        return self.__redisManager.getRedis()

    def save_plate(self, plate):
        self.__get_redis().sadd("kpl_forbidden_plates", plate)
        self.__get_redis().expire("kpl_forbidden_plates", tool.get_expire())
        RedisUtils.sadd(self.__get_redis(), "kpl_forbidden_plates", plate)
        RedisUtils.expire(self.__get_redis(), "kpl_forbidden_plates", tool.get_expire())

    def list_all(self):
        return self.__get_redis().smembers("kpl_forbidden_plates")
        return RedisUtils.smembers(self.__get_redis(), "kpl_forbidden_plates")


class LimitUpCodesPlateKeyManager:
@@ -90,7 +91,7 @@

    # 今日涨停原因变化
    def set_today_limit_up_reason_change(self, code, from_reason, to_reason):
        self.__get_redis().sadd(f"kpl_limit_up_reason_his-{code}", from_reason)
        RedisUtils.sadd(self.__get_redis(), f"kpl_limit_up_reason_his-{code}", from_reason)
        self.__get_redis().expire(f"kpl_limit_up_reason_his-{code}", tool.get_expire())
        self.__set_total_keys(code)

@@ -258,7 +259,7 @@

    def set_history_limit_up_reason(self, code, reasons):
        self.__history_limit_up_reason_dict[code] = set(reasons)
        self.__get_redis().setex(f"kpl_his_limit_up_reason-{code}", tool.get_expire(), json.dumps(list(reasons)))
        RedisUtils.setex(self.__get_redis(),f"kpl_his_limit_up_reason-{code}", tool.get_expire(), json.dumps(list(reasons)))
        logger_kpl_debug.debug(f"设置历史涨停原因：{code}-{reasons}")

    # 如果返回值不为None表示已经加载过历史原因了
@@ -279,7 +280,7 @@

    def set_blocks(self, code, blocks):
        self.__blocks_dict[code] = set(blocks)
        self.__get_redis().setex(f"kpl_blocks-{code}", tool.get_expire(), json.dumps(list(blocks)))
        RedisUtils.setex(self.__get_redis(),f"kpl_blocks-{code}", tool.get_expire(), json.dumps(list(blocks)))

    def get_blocks(self, code):
        reasons = self.__blocks_dict.get(code)
@@ -321,7 +322,7 @@
        if code in LimitUpCodesPlateKeyManager.today_total_limit_up_reason_dict:
            k1 = {LimitUpCodesPlateKeyManager.today_total_limit_up_reason_dict[code]}
        # 加载今日历史原因
        k11 = self.__get_redis().smembers(f"kpl_limit_up_reason_his-{code}")
        k11 = RedisUtils.smembers(self.__get_redis(), f"kpl_limit_up_reason_his-{code}")
        k2 = self.__CodesPlateKeysManager.get_history_limit_up_reason(code)
        if k2 is None:
            k2 = set()

 third_data/kpl_data_manager.py

@@ -3,6 +3,7 @@
import time

import constant
from db.redis_manager import RedisUtils
from utils import tool

# 开盘啦历史涨停数据管理
@@ -22,13 +23,13 @@
        return self.__redisManager.getRedis()

    def save_reason(self, code, reason):
        self.__get_redis().setex(f"kpl_limitup_reason-{code}", tool.get_expire(), reason)
        RedisUtils.setex(self.__get_redis(),f"kpl_limitup_reason-{code}", tool.get_expire(), reason)

    def list_all(self):
        keys = self.__get_redis().keys("kpl_limitup_reason-*")
        keys = RedisUtils.keys(self.__get_redis(), "kpl_limitup_reason-*")
        dict_ = {}
        for k in keys:
            val = self.__get_redis().get(k)
            val = RedisUtils.get(self.__get_redis(), k)
            dict_[k.split("-")[1]] = val
        return dict_


 ths/client_manager.py

@@ -1,6 +1,7 @@
# 客户端管理器
import json

from db.redis_manager import RedisUtils
from user import authority
from db import redis_manager
from utils import import_util
@@ -12,7 +13,7 @@

def getValidL2Clients():
    redis = __redisManager.getRedis()
    keys = redis.keys("client-active-*")
    keys = RedisUtils.keys(redis, "client-active-*")
    client_ids = []
    for k in keys:
        _id = k.split("client-active-")[1]
@@ -27,7 +28,7 @@
# 获取客户端IP
def getActiveClientIP(client_id):
    redis = __redisManager.getRedis()
    val = redis.get("client-active-{}".format(client_id))
    val = RedisUtils.get(redis, "client-active-{}".format(client_id))
    if val is None:
        return None
    val = json.loads(val)
@@ -39,7 +40,7 @@
        return

    redis = __redisManager.getRedis()
    redis.setex("client-active-{}".format(client_id), 10, json.dumps((host, thsDead)))
    RedisUtils.setex(redis,"client-active-{}".format(client_id), 10, json.dumps((host, thsDead)))
    if ths_util:
        ths_util.set_ths_dead_state(client_id, thsDead)

@@ -47,7 +48,7 @@
# 获取客户端同花顺状态
def getTHSState(client_id):
    redis = __redisManager.getRedis()
    val = redis.get("client-active-{}".format(client_id))
    val = RedisUtils.get(redis, "client-active-{}".format(client_id))
    if val is None:
        return None
    val = json.loads(val)

 ths/l2_code_operate.py

@@ -7,6 +7,7 @@
import logging
import threading

from db.redis_manager import RedisUtils
from ths import client_manager
from code_attribute import gpcode_manager
from l2 import l2_data_manager
@@ -222,7 +223,7 @@
    # 设置代码操作状态，服务器保存的代码是否与实际设置的代码保持一致
    @classmethod
    def set_operate_code_state(cls, client_id, channel, state):
        cls.getRedis().setex("code-operate_state-{}-{}".format(client_id, channel), 10, state)
        RedisUtils.setex(cls.getRedis(),"code-operate_state-{}-{}".format(client_id, channel), 10, state)

    def get_operate_code_state(self, client_id, channel):
        value = self.getRedis().get("code-operate_state-{}-{}".format(client_id, channel))
@@ -234,7 +235,7 @@
    @classmethod
    def set_read_queue_valid(cls):
        redis = cls.getRedis()
        redis.setex("operate_queue_read_state", 20, 1)
        RedisUtils.setex( redis,"operate_queue_read_state", 20, 1)

    @classmethod
    def is_read_queue_valid(cls):

 ths/l2_listen_pos_health_manager.py

@@ -2,6 +2,7 @@
同花顺l2监听位置健康度管理
"""
# 不健康
from db.redis_manager import RedisUtils
from utils import tool
from db import redis_manager

@@ -17,7 +18,7 @@


def __set_health_state(client_id, pos, state):
    __get_redis().setex(f"l2_pos_health_state-{client_id}-{pos}", tool.get_expire(), state)
    RedisUtils.setex(__get_redis(),f"l2_pos_health_state-{client_id}-{pos}", tool.get_expire(), state)


def __get_health_state(client_id, pos):

 ths/ths_util.py

@@ -9,6 +9,7 @@
import win32gui

from db import redis_manager
from db.redis_manager import RedisUtils
from utils import tool
from trade import trade_gui

@@ -179,10 +180,10 @@
    redis = __redisManager.getRedis()
    key = "ths_state_dead_count-{}".format(client_id)
    if not dead:
        redis.setex(key, tool.get_expire(), 0)
        RedisUtils.setex(redis,key, tool.get_expire(), 0)
    else:
        redis.incrby(key, 1)
        redis.expire(key, tool.get_expire())
        RedisUtils.expire(redis, key, tool.get_expire())


# 同花顺是否卡死

 trade/bidding_money_manager.py

@@ -3,6 +3,7 @@
"""
import json

from db.redis_manager import RedisUtils
from utils import tool
from db import redis_manager

@@ -24,7 +25,7 @@
        else:
            money = int(data[1][:-1])
        money_list.append((data[0], money))
    __get_redis().setex("bidding_money", tool.get_expire(), json.dumps(money_list))
    RedisUtils.setex(__get_redis(),"bidding_money", tool.get_expire(), json.dumps(money_list))


# 获取竞价金额

 trade/deal_big_money_manager.py

@@ -3,6 +3,7 @@
"""
import json

from db.redis_manager import RedisUtils
from utils import tool
from db import redis_manager
from l2 import l2_data_util, l2_data_source_util
@@ -29,12 +30,12 @@


def __save_traded_index(code, index):
    __get_redis().sadd(f"deal_indexes-{code}", index)
    __get_redis().expire(f"deal_indexes-{code}", tool.get_expire())
    RedisUtils.sadd(__get_redis(), f"deal_indexes-{code}", index)
    RedisUtils.expire(__get_redis(), f"deal_indexes-{code}", tool.get_expire())


def __get_traded_indexes(code):
    return __get_redis().smembers(f"deal_indexes-{code}")
    return RedisUtils.smembers(__get_redis(), f"deal_indexes-{code}")


# 获取成交的索引
@@ -56,7 +57,7 @@

# 设置成交进度
def __set_deal_compute_progress(code, index, money):
    __get_redis().setex(f"deal_compute_info-{code}", tool.get_expire(), json.dumps((index, money)))
    RedisUtils.setex(__get_redis(),f"deal_compute_info-{code}", tool.get_expire(), json.dumps((index, money)))
    __deal_compute_progress_cache[code] = (index, money)



 trade/huaxin/huaxin_trade_record_manager.py

@@ -6,6 +6,7 @@
import datetime
import json

from db.redis_manager import RedisUtils
from utils import tool
from db import mysql_data, redis_manager
from third_data.history_k_data_util import HistoryKDatasUtils
@@ -114,7 +115,7 @@
    # 保存代码的量
    @classmethod
    def __save_code_volume(cls, code, volume):
        cls.__get_redis().setex(f"available_position_{code}", tool.get_expire(), f"{volume}")
        RedisUtils.setex(cls.__get_redis(),f"available_position_{code}", tool.get_expire(), f"{volume}")

    @classmethod
    def get_code_volume(cls, code):
@@ -291,7 +292,7 @@

    @classmethod
    def save_data(cls, data):
        cls.get_redis().setex("huaxin_money", tool.get_expire(), json.dumps(data))
        RedisUtils.setex(cls.get_redis(),"huaxin_money", tool.get_expire(), json.dumps(data))

    @classmethod
    def get_data(cls):

 trade/huaxin/trade_api_server.py

@@ -11,6 +11,7 @@
import inited_data
from code_attribute import gpcode_manager
from db import redis_manager, mysql_data
from db.redis_manager import RedisUtils
from l2 import l2_data_manager_new
from l2.huaxin import huaxin_target_codes_manager
from third_data import block_info
@@ -353,11 +354,11 @@
                        _start_time = time.time()
                        times = []
                        for i in range(0, 100):
                            redis.sadd("test_set", f"000000:{i}")
                            RedisUtils.sadd(redis, "test_set", f"000000:{i}")
                        times.append(time.time() - _start_time)
                        _start_time = time.time()
                        for i in range(0, 20):
                            redis.smembers("test_set")
                            RedisUtils.smembers(redis, "test_set")
                        times.append(time.time() - _start_time)
                        return_str = json.dumps(
                            {"code": 0, "data": times, "msg": ""})
@@ -443,17 +444,4 @@


if __name__ == "__main__":
    redis = redis_manager.RedisManager(0).getRedis()
    for i in range(100):
        _start_time = time.time()
        times = []
        for i in range(0, 100):
            redis.sadd("test_set", f"000000:{i}")
        times.append(time.time() - _start_time)
        _start_time = time.time()
        for i in range(0, 20):
            redis.smembers("test_set")
        times.append(time.time() - _start_time)
        return_str = json.dumps(
            {"code": 0, "data": times, "msg": ""})
        print(return_str)
    pass

 trade/huaxin_trade.py

@@ -12,7 +12,7 @@
# 交易订单号管理
import constant
from utils import tool
from db.redis_manager import RedisManager
from db.redis_manager import RedisManager, RedisUtils
from log_module.log import logger_huaxin_trade


@@ -26,8 +26,8 @@
    # 添加订单ID
    @classmethod
    def add_order_id(cls, code, account_id, order_id):
        cls.__get_redis().sadd(f"huaxin_order_id-{code}", json.dumps((account_id, order_id)))
        cls.__get_redis().expire(f"huaxin_order_id-{code}", tool.get_expire())
        RedisUtils.sadd(cls.__get_redis(), f"huaxin_order_id-{code}", json.dumps((account_id, order_id)))
        RedisUtils.expire(cls.__get_redis(), f"huaxin_order_id-{code}", tool.get_expire())

    # 删除订单ID
    @classmethod
@@ -37,7 +37,7 @@
    # 查询所有的订单号
    @classmethod
    def list_order_ids(cls, code):
        return cls.__get_redis().smembers(f"huaxin_order_id-{code}")
        return RedisUtils.smembers(cls.__get_redis(), f"huaxin_order_id-{code}")


class TradeApi:

 trade/l2_trade_util.py

@@ -1,5 +1,6 @@
# 是否在禁止交易代码中
from db import redis_manager
from db.redis_manager import RedisUtils
from utils import tool

__redis_manager = redis_manager.RedisManager(2)
@@ -14,8 +15,8 @@

    @classmethod
    def add_code(cls, code):
        cls.__get_redis().sadd("white_list_codes", code)
        cls.__get_redis().expire("white_list_codes", tool.get_expire())
        RedisUtils.sadd(cls.__get_redis(), "white_list_codes", code)
        RedisUtils.expire(cls.__get_redis(), "white_list_codes", tool.get_expire())

    @classmethod
    def remove_code(cls, code):
@@ -27,11 +28,11 @@

    @classmethod
    def list_codes(cls):
        return cls.__get_redis().smembers("white_list_codes")
        return RedisUtils.smembers(cls.__get_redis(), "white_list_codes")

    @classmethod
    def clear(cls):
        cls.__get_redis().delete("white_list_codes")
        RedisUtils.delete( cls.__get_redis(), "white_list_codes")


class BlackListCodeManager:
@@ -43,8 +44,8 @@

    @classmethod
    def add_code(cls, code):
        cls.__get_redis().sadd("forbidden-trade-codes", code)
        cls.__get_redis().expire("forbidden-trade-codes", tool.get_expire())
        RedisUtils.sadd( cls.__get_redis(), "forbidden-trade-codes", code)
        RedisUtils.expire(cls.__get_redis(), "forbidden-trade-codes", tool.get_expire())

    @classmethod
    def remove_code(cls, code):
@@ -56,11 +57,11 @@

    @classmethod
    def list_codes(cls):
        return cls.__get_redis().smembers("forbidden-trade-codes")
        return RedisUtils.smembers(cls.__get_redis(), "forbidden-trade-codes")

    @classmethod
    def clear(cls):
        cls.__get_redis().delete("forbidden-trade-codes")
        RedisUtils.delete(cls.__get_redis(), "forbidden-trade-codes")


#  初始化禁止交易代码库

 trade/trade_data_manager.py

@@ -7,6 +7,7 @@

# 交易撤销数据管理器
import constant
from db.redis_manager import RedisUtils
from utils import global_util, tool
import l2_data_util
from db import redis_manager
@@ -61,14 +62,14 @@
    @classmethod
    def set_buy_position_info(cls, code, capture_time, trade_time, last_data, last_data_index):
        redis = cls.redisManager.getRedis()
        redis.setex("buy_position_info-{}".format(code), tool.get_expire(),
                    json.dumps((capture_time, trade_time, last_data, last_data_index)))
        RedisUtils.setex(redis, "buy_position_info-{}".format(code), tool.get_expire(),
                         json.dumps((capture_time, trade_time, last_data, last_data_index)))

    # 获取买入点信息
    @classmethod
    def get_buy_position_info(cls, code):
        redis = cls.redisManager.getRedis()
        val_str = redis.get("buy_position_info-{}".format(code))
        val_str = RedisUtils.get(redis,"buy_position_info-{}".format(code))
        if val_str is None:
            return None, None, None, None
        else:
@@ -79,7 +80,7 @@
    @classmethod
    def remove_buy_position_info(cls, code):
        redis = cls.redisManager.getRedis()
        redis.delete("buy_position_info-{}".format(code))
        RedisUtils.delete( redis,"buy_position_info-{}".format(code))

    # 设置买入确认点信息
    @classmethod
@@ -87,7 +88,7 @@
        logger_trade.debug("买入确认点信息： code:{} index:{} data:{}", code, index, data)
        redis = cls.redisManager.getRedis()
        key = "buy_sure_position-{}".format(code)
        redis.setex(key, tool.get_expire(), json.dumps((index, data)))
        RedisUtils.setex(redis, key, tool.get_expire(), json.dumps((index, data)))
        cls.buy_sure_position_dict[code] = (index, data)
        # 移除下单信号的详细信息
        cls.remove_buy_position_info(code)
@@ -97,7 +98,7 @@
    def __clear_buy_sure_position(cls, code):
        redis = cls.redisManager.getRedis()
        key = "buy_sure_position-{}".format(code)
        redis.delete(key)
        RedisUtils.delete(redis, key)
        if code in cls.buy_sure_position_dict:
            cls.buy_sure_position_dict.pop(code)

@@ -110,7 +111,7 @@

        redis = cls.redisManager.getRedis()
        key = "buy_sure_position-{}".format(code)
        val = redis.get(key)
        val = RedisUtils.get(redis, key)
        if val is None:
            return None, None
        else:
@@ -168,25 +169,25 @@
    # 保存跌价的时间
    def __save_down_price_time(self, code, time_str):
        key = "under_water_last_time-{}".format(code)
        self.__get_redis().setex(key, tool.get_expire(), time_str)
        RedisUtils.setex(self.__get_redis(),key, tool.get_expire(), time_str)

    def __remove_down_price_time(self, code):
        key = "under_water_last_time-{}".format(code)
        self.__get_redis().delete(key)
        RedisUtils.delete( self.__get_redis(), key)

    def __get_last_down_price_time(self, code):
        key = "under_water_last_time-{}".format(code)
        return self.__get_redis().get(key)
        return RedisUtils.get(self.__get_redis(), key)

    def __increment_down_price_time(self, code, seconds):
        key = "under_water_seconds-{}".format(code)
        self.__get_redis().incrby(key, seconds)
        # 设置个失效时间
        self.__get_redis().expire(key, tool.get_expire())
        RedisUtils.expire(self.__get_redis(), key, tool.get_expire())

    def __get_down_price_time_as_seconds(self, code):
        key = "under_water_seconds-{}".format(code)
        val = self.__get_redis().get(key)
        val = RedisUtils.get(self.__get_redis(), key)
        if val is None:
            return None
        else:
@@ -195,35 +196,34 @@
    # 清除所有的水下捞数据
    def clear_under_water_data(self):
        key = "under_water_*"
        keys = self.__get_redis().keys(key)
        keys = RedisUtils.keys(self.__get_redis(), key)
        for k in keys:
            self.__get_redis().delete(k)
            RedisUtils.delete(self.__get_redis(), k)

    def __save_current_price_codes_count(self, count):
        key = "current_price_codes_count"
        self.__get_redis().setex(key, 10, count)
        RedisUtils.setex(self.__get_redis(),key, 10, count)

    def __get_current_price_codes_count(self):
        key = "current_price_codes_count"
        count = self.__get_redis().get(key)
        count = RedisUtils.get(self.__get_redis(),key)
        return 0 if count is None else count

    # 保存当前涨幅
    def __save_current_rate(self, code, rate):
        key = "code_current_rate-{}".format(code)
        self.__get_redis().setex(key, tool.get_expire(), rate)
        RedisUtils.setex(self.__get_redis(),key, tool.get_expire(), rate)

    # 获取当前涨幅
    def __get_current_rate(self, code):
        key = "code_current_rate-{}".format(code)
        rate = self.__get_redis().get(key)
        rate = RedisUtils.get(self.__get_redis(), key)
        if rate is not None:
            return float(rate)
        return None

    def get_current_rate(self, code):
        return self.__get_current_rate(code)


    def process_rate(self, code, rate, time_str):
        # 保存目前的代码涨幅
@@ -287,7 +287,7 @@
    # 获取涨幅前几的代码
    def get_top_rate_codes(self, top_n):
        keys = "code_current_rate-*"
        keys = self.__get_redis().keys(keys)
        keys = RedisUtils.keys(self.__get_redis(), keys)
        infos = []
        for k in keys:
            code = k.split("-")[1]
@@ -314,12 +314,12 @@
    def __incre_place_order_count(cls, code):
        key = "place_order_count-{}".format(code)
        cls.__get_redis().incrby(key, 1)
        cls.__get_redis().expire(key, tool.get_expire())
        RedisUtils.expire(cls.__get_redis(), key, tool.get_expire())

    @classmethod
    def __get_place_order_count(cls, code):
        key = "place_order_count-{}".format(code)
        count = cls.__get_redis().get(key)
        count = RedisUtils.get(cls.__get_redis(), key)
        if count is not None:
            return int(count)
        return 0
@@ -335,7 +335,7 @@
    @classmethod
    def clear_place_order_count(cls, code):
        key = "place_order_count-{}".format(code)
        cls.__get_redis().delete(key)
        RedisUtils.delete(cls.__get_redis(), key)


if __name__ == "__main__":

 trade/trade_gui.py

@@ -11,6 +11,7 @@
import win32gui
import win32con

from db.redis_manager import RedisUtils
from ocr import ocr_util
from trade import l2_trade_util
from db import redis_manager
@@ -604,7 +605,7 @@
    @classmethod
    def __save_code_win(cls, code, win):
        key = "buywin_distribute-{}".format(code)
        cls.__get_redis().setex(key, tool.get_expire(), win)
        RedisUtils.setex(cls.__get_redis(), key, tool.get_expire(), win)

    # 获取窗口分配的代码
    @classmethod
@@ -619,13 +620,13 @@
    @classmethod
    def __del_code_win(cls, code):
        key = "buywin_distribute-{}".format(code)
        cls.__get_redis().delete(key)
        RedisUtils.delete(cls.__get_redis(), key)

    # 获取所有已经分配窗口的代码
    @classmethod
    def __get_distributed_win_codes(cls):
        key = "buywin_distribute-*"
        keys = cls.__get_redis().keys(key)
        keys = RedisUtils.keys(cls.__get_redis(), key)
        codes = []
        for k in keys:
            codes.append(k.replace("buywin_distribute-", ""))
@@ -636,7 +637,7 @@
    def __get_available_win(cls):
        # 是否有可用的还未分配的窗口
        key = "buywin_distribute-*"
        keys = cls.__get_redis().keys(key)
        keys = RedisUtils.keys(cls.__get_redis(), key)
        win_list = cls.get_buy_wins()
        if len(win_list) < 1:
            raise Exception("必须要有一个买入窗口")
@@ -718,7 +719,7 @@
    @classmethod
    def get_distributed_code_wins(cls):
        key = "buywin_distribute-*"
        keys = cls.__get_redis().keys(key)
        keys = RedisUtils.keys(cls.__get_redis(), key)
        results = []
        for k in keys:
            code = k.split("-")[-1]

 trade/trade_huaxin.py

@@ -5,7 +5,7 @@
import time

import constant
from db.redis_manager import RedisManager
from db.redis_manager import RedisManager, RedisUtils
from log_module.log import logger_juejin_trade, hx_logger_trade_debug
from trade.huaxin import huaxin_trade_api
from utils import tool, huaxin_util
@@ -25,8 +25,8 @@
    # 添加订单ID
    @classmethod
    def add_order_id(cls, code, account_id, order_id):
        cls.__get_redis().sadd(f"huaxin_order_id-{code}", json.dumps((account_id, order_id)))
        cls.__get_redis().expire(f"huaxin_order_id-{code}", tool.get_expire())
        RedisUtils.sadd( cls.__get_redis(), f"huaxin_order_id-{code}", json.dumps((account_id, order_id)))
        RedisUtils.expire(cls.__get_redis(), f"huaxin_order_id-{code}", tool.get_expire())

    # 删除订单ID
    @classmethod
@@ -36,7 +36,7 @@
    # 查询所有的订单号
    @classmethod
    def list_order_ids(cls, code):
        return cls.__get_redis().smembers(f"huaxin_order_id-{code}")
        return RedisUtils.smembers(cls.__get_redis(), f"huaxin_order_id-{code}")


def init(context):

 trade/trade_juejin.py

@@ -9,7 +9,7 @@

import constant
from code_attribute import gpcode_manager
from db.redis_manager import RedisManager
from db.redis_manager import RedisManager, RedisUtils
from log_module.log import logger_juejin_trade
from utils import network_util, tool

@@ -34,7 +34,7 @@
    # 添加订单ID
    @classmethod
    def add_order_id(cls, code, account_id, order_id):
        cls.__get_redis().sadd(f"juejin_order_id-{code}", json.dumps((account_id, order_id)))
        RedisUtils.sadd(cls.__get_redis(),f"juejin_order_id-{code}", json.dumps((account_id, order_id)))
        cls.__get_redis().expire(f"juejin_order_id-{code}", tool.get_expire())

    # 删除订单ID
@@ -45,7 +45,7 @@
    # 查询所有的订单号
    @classmethod
    def list_order_ids(cls, code):
        return cls.__get_redis().smembers(f"juejin_order_id-{code}")
        return RedisUtils.smembers(cls.__get_redis(), f"juejin_order_id-{code}")


def init(context):

 trade/trade_manager.py

@@ -9,6 +9,7 @@
import dask

from db import mysql_data, redis_manager
from db.redis_manager import RedisUtils
from output import kp_client_msg_manager
from trade import trade_data_manager, l2_trade_util, trade_juejin, trade_huaxin

@@ -52,12 +53,12 @@
    # 开启购买入口
    @classmethod
    def open_buy(cls):
        cls.__get_redis().setex("trade_buy_state", tool.get_expire(), 1)
        RedisUtils.setex(cls.__get_redis(),"trade_buy_state", tool.get_expire(), 1)

    # 关闭购买入口
    @classmethod
    def close_buy(cls):
        cls.__get_redis().setex("trade_buy_state", tool.get_expire(), 0)
        RedisUtils.setex(cls.__get_redis(), "trade_buy_state", tool.get_expire(), 0)

    # 是否可以下单
    @classmethod
@@ -90,7 +91,7 @@
    def set_mode(cls, mode):
        if mode != cls.MODE_ONLY_BUY_WANT_CODES and mode != cls.MODE_BUY_ALL:
            raise Exception("mode参数值错误")
        cls.__get_redis().setex("trade_buy_mode", tool.get_expire(), mode)
        RedisUtils.setex(cls.__get_redis(), "trade_buy_mode", tool.get_expire(), mode)

    # 是否可以下单
    @classmethod
@@ -113,7 +114,7 @@

    @classmethod
    def add_code(cls, code):
        cls.__get_redis().sadd(cls.__key, code)
        RedisUtils.sadd( cls.__get_redis(), cls.__key, code)

    @classmethod
    def remove_code(cls, code):
@@ -125,7 +126,7 @@

    @classmethod
    def clear(cls):
        cls.__get_redis().delete(cls.__key)
        RedisUtils.delete( cls.__get_redis(), cls.__key)


# 获取交易状态
@@ -141,12 +142,12 @@
def set_trade_state(code, state):
    logger_trade.info("set_trade_state {}-{}".format(code, state))
    redis = __redis_manager.getRedis()
    redis.setex("trade-state-{}".format(code), tool.get_expire(), state)
    RedisUtils.setex(redis, "trade-state-{}".format(code), tool.get_expire(), state)


def get_codes_by_trade_state(state):
    redis = __redis_manager.getRedis()
    keys = redis.keys("trade-state-*")
    keys = RedisUtils.keys(redis, "trade-state-*")
    codes = []
    if keys is not None:
        for key in keys:
@@ -157,7 +158,7 @@

def get_codes_by_trade_states(states):
    redis = __redis_manager.getRedis()
    keys = redis.keys("trade-state-*")
    keys = RedisUtils.keys(redis, "trade-state-*")
    codes = []
    if keys is not None:
        for key in keys:
@@ -185,7 +186,7 @@
def save_trade_success_data(datas, day=datetime.datetime.now().strftime("%Y%m%d")):
    redis = __redis_manager.getRedis()
    time_str = tool.get_now_time_str()
    redis.setex("trade-success-latest-time", tool.get_expire(), time_str)
    RedisUtils.setex(redis, "trade-success-latest-time", tool.get_expire(), time_str)
    mysqldb = mysql_data.Mysqldb()
    # 合并同一合同编号
    dict_ = {}
@@ -240,8 +241,8 @@

    # 保存最新的委托数据
    redis = __redis_manager.getRedis()
    redis.setex("trade-delegate-latest", tool.get_expire(), json.dumps(datas))
    redis.setex("trade-delegate-latest-time", tool.get_expire(), time_str)
    RedisUtils.setex(redis,"trade-delegate-latest", tool.get_expire(), json.dumps(datas))
    RedisUtils.setex(redis,"trade-delegate-latest-time", tool.get_expire(), time_str)


# 获取交易成功数据
@@ -516,30 +517,30 @@
def __clear_data(code):
    redis_l2 = redis_manager.RedisManager(1).getRedis()

    keys = redis_l2.keys("*{}*".format(code))
    keys = RedisUtils.keys(redis_l2, "*{}*".format(code))
    for k in keys:
        # if (k.find("l2-") is None or k.find("l2-") < 0) and (k.find("big_data-") is None or k.find("big_data-") < 0):
        redis_l2.delete(k)
        RedisUtils.delete(redis_l2, k)

    redis_trade = redis_manager.RedisManager(2).getRedis()
    redis_trade.delete("trade-state-{}".format(code))
    RedisUtils.delete(redis_trade, "trade-state-{}".format(code))

    redis_info = redis_manager.RedisManager(0).getRedis()
    keys = redis_info.keys("*{}*".format(code))
    keys = RedisUtils.keys(redis_info, "*{}*".format(code))
    for k in keys:
        if k.find("pre") is not None:
            continue
        if k.find("zyltgb") is not None:
            continue

        redis_info.delete(k)
        RedisUtils.delete(redis_info, k)


def __clear_big_data():
    redis_l2 = redis_manager.RedisManager(1).getRedis()
    keys = redis_l2.keys("big_data-*")
    keys = RedisUtils.keys(redis_l2, "big_data-*")
    for k in keys:
        redis_l2.delete(k)
        RedisUtils.delete( redis_l2, k)


if __name__ == "__main__":

 trade/trade_queue_manager.py

@@ -4,6 +4,7 @@

from code_attribute import gpcode_manager
from db import redis_manager
from db.redis_manager import RedisUtils
from utils import tool
from trade import trade_manager

@@ -19,37 +20,37 @@
    # 保存最大量
    def __save_max_buy1_volume(self, code, volume):
        key = "max_buy1_volumn-{}".format(code)
        self.__get_redis().setex(key, tool.get_expire(), volume)
        RedisUtils.setex(self.__get_redis(), key, tool.get_expire(), volume)

    def __get_max_buy1_volume(self, code):
        key = "max_buy1_volumn-{}".format(code)
        val = self.__get_redis().get(key)
        val = RedisUtils.get(self.__get_redis(), key)
        if val is not None:
            return int(val)
        return None

    def __del_max_buy1_volume(self, code):
        key = "max_buy1_volumn-{}".format(code)
        val = self.__get_redis().delete(key)
        val = RedisUtils.delete(self.__get_redis(), key)

    def __save_recod(self, code, time_str, volumn):

        # 保存每一次的
        key = "buy1_volumn-{}-{}".format(code, time_str)
        self.__get_redis().setex(key, tool.get_expire(), volumn)
        RedisUtils.setex(self.__get_redis(), key, tool.get_expire(), volumn)
        # 保存最近的
        key = "buy1_volumn_latest_info-{}".format(code)
        self.__get_redis().setex(key, tool.get_expire(), json.dumps((time_str, volumn)))
        RedisUtils.setex(self.__get_redis(), key, tool.get_expire(), json.dumps((time_str, volumn)))

    # 保存上一次数据
    def __save_last_recod(self, code, time_str, volumn):
        # 保存最近的
        key = "buy1_volumn_last_info-{}".format(code)
        self.__get_redis().setex(key, tool.get_expire(), json.dumps((time_str, volumn)))
        RedisUtils.setex(self.__get_redis(), key, tool.get_expire(), json.dumps((time_str, volumn)))

    def __get_last_record(self, code):
        key = "buy1_volumn_last_info-{}".format(code)
        val = self.__get_redis().get(key)
        val = RedisUtils.get(self.__get_redis(), key)
        if val is None:
            return None, None
        val = json.loads(val)
@@ -57,7 +58,7 @@

    def __get_latest_record(self, code):
        key = "buy1_volumn_latest_info-{}".format(code)
        val = self.__get_redis().get(key)
        val = RedisUtils.get(self.__get_redis(), key)
        if val is None:
            return None, None
        val = json.loads(val)
@@ -66,17 +67,17 @@
    # 添加记录
    def __add_recod(self, code):
        key = "buy1_volumn_codes"
        self.__get_redis().sadd(key, code)
        self.__get_redis().expire(key, 10)
        RedisUtils.sadd( self.__get_redis(), key, code)
        RedisUtils.expire(self.__get_redis(), key, 10)

    # 获取当前正在监听的代码
    def get_current_codes(self):
        key = "buy1_volumn_codes"
        return self.__get_redis().smembers(key)
        return RedisUtils.smembers(self.__get_redis(), key)

    def get_buy_1_volumn(self, code, time_str):
        key = "buy1_volumn-{}-{}".format(code, time_str)
        return self.__get_redis().get(key)
        return RedisUtils.get(self.__get_redis(), key)

    # 返回是否需要更新数据,是否需要撤单，撤单原因
    def save(self, code, time_str, volumn, price):
@@ -174,13 +175,13 @@
    def __save_recod(self, code, time_str, volumn):
        # 保存每一次的
        key = "buy1_volumn_juejin-{}-{}".format(code, time_str)
        self.__get_redis().setex(key, tool.get_expire(), volumn)
        RedisUtils.setex(self.__get_redis(), key, tool.get_expire(), volumn)
        key = "buy1_volumn_juejin_latest_info-{}".format(code)
        self.__get_redis().setex(key, tool.get_expire(), volumn)
        RedisUtils.setex(self.__get_redis(), key, tool.get_expire(), volumn)

    def __get_latest_record(self, code):
        key = "buy1_volumn_juejin_latest_info-{}".format(code)
        val = self.__get_redis().get(key)
        val = RedisUtils.get(self.__get_redis(), key)
        if val is None:
            return None, None
        val = json.loads(val)
@@ -220,11 +221,11 @@
    def __save_latest_recod(self, code, info):
        # 保存每一次的
        key = "ths_l2_latest_trade_info-{}".format(code)
        self.__get_redis().setex(key, tool.get_expire(), json.dumps(info))
        RedisUtils.setex(self.__get_redis(), key, tool.get_expire(), json.dumps(info))

    def __get_latest_record(self, code):
        key = "ths_l2_latest_trade_info-{}".format(code)
        val = self.__get_redis().get(key)
        val = RedisUtils.get(self.__get_redis(), key)
        if val is None:
            return None
        return json.loads(val)
@@ -233,14 +234,14 @@

    def __add_buy1_code(self, code):
        key = "buy1_volumn_codes"
        self.__get_redis().sadd(key, code)
        self.__get_redis().expire(key, 10)
        RedisUtils.sadd( self.__get_redis(), key, code)
        RedisUtils.expire(self.__get_redis(), key, 10)

        # 获取当前正在监听的代码

    def get_current_codes(self):
        key = "buy1_volumn_codes"
        return self.__get_redis().smembers(key)
        return RedisUtils.smembers(self.__get_redis(), key)

    def save_recod(self, code, data):
        _str = json.dumps(data)