blame | 历史 | 补丁 | 提交 | 提交对比 | ignore whitespace
Administrator
2023-08-02 a3c05bddc4c61d63b804ee541cf6dd01717ba94d 
 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)




    # 处理数据，返回是否需要撤单


    # 处理范围：买入执行位-当前最新位置