From 6f324f1471a5e28188e9f4206b46cbafdf09d04c Mon Sep 17 00:00:00 2001
From: Administrator <admin@example.com>
Date: 星期一, 16 一月 2023 17:58:31 +0800
Subject: [PATCH] 增加图像识别接口，禁止下单策略优化
---
l2_data_manager.py | 931 ---------------------------------------------------------
1 files changed, 4 insertions(+), 927 deletions(-)
diff --git a/l2_data_manager.py b/l2_data_manager.py
index 708ae99..99ad7fe 100644
--- a/l2_data_manager.py
+++ b/l2_data_manager.py
@@ -78,7 +78,7 @@
_key = "buy_compute_index_info-{}".format(code)
_data_json = redis.get(_key)
if _data_json is None:
- return None, None, None, 0, 0, -1
+ return None, None, None, 0, 0, []
_data = json.loads(_data_json)
return _data[0], _data[1], _data[2], _data[3], _data[4], _data[5]
@@ -88,18 +88,18 @@
# compute_index 璁＄畻浣嶇疆
# nums 绱绾拱棰�
@staticmethod
- def set_buy_compute_start_data(code, buy_single_index, buy_exec_index, compute_index, nums, count, max_num_index):
+ def set_buy_compute_start_data(code, buy_single_index, buy_exec_index, compute_index, nums, count, max_num_sets):
redis = TradePointManager.__get_redis()
expire = tool.get_expire()
_key = "buy_compute_index_info-{}".format(code)
if buy_single_index is not None:
redis.setex(_key, expire,
- json.dumps((buy_single_index, buy_exec_index, compute_index, nums, count, max_num_index)))
+ json.dumps((buy_single_index, buy_exec_index, compute_index, nums, count, list(max_num_sets))))
else:
_buy_single_index, _buy_exec_index, _compute_index, _nums, _count, _max_num_index = TradePointManager.get_buy_compute_start_data(
code)
redis.setex(_key, expire,
- json.dumps((_buy_single_index, buy_exec_index, compute_index, nums, count, max_num_index)))
+ json.dumps((_buy_single_index, buy_exec_index, compute_index, nums, count, list(max_num_sets))))
# 鑾峰彇鎾や拱鍏ュ紑濮嬭绠楃殑淇℃伅
# 杩斿洖鏁版嵁鐨勫唴瀹逛负锛氭挙閿�鐐圭储寮� 鎾や拱绾拱棰� 璁＄畻鐨勬暟鎹储寮�
@@ -481,929 +481,6 @@
if int(val["operateType"]) == 2:
return True
return False
-
-
-# L2浜ゆ槗鏁版嵁澶勭悊鍣�
-# 涓�浜涘父瑙佺殑姒傚康锛�
-# 涔板叆淇″彿浣嶇疆(鍑虹幇涓嬪崟淇″彿鐨勭涓�鏉℃暟鎹殑浣嶇疆)锛歜uy_single_index
-# 涔板叆鎵ц浣嶇疆锛堢鍚堜笅鍗曚俊鍙风殑鏈�鍚庝竴鏉℃暟鎹級锛歜uy_exec_index
-# 璁＄畻浣嶇疆锛堝綋鍓嶈绠楃殑鏁翠釜璁＄畻鐨勪綅缃級锛歝ompute_index
-#
-
-class L2TradeDataProcessor:
- unreal_buy_dict = {}
- random_key = {}
-
- @classmethod
- def debug(cls, code, content, *args):
- logger_l2_trade.debug(("thread-id={} code={} ".format(cls.random_key[code], code) + content).format(*args))
-
- @classmethod
- def cancel_debug(cls, code, content, *args):
- logger_l2_trade_cancel.debug(
- ("thread-id={} code={} ".format(cls.random_key[code], code) + content).format(*args))
-
- @classmethod
- def buy_debug(cls, code, content, *args):
- logger_l2_trade_buy.debug(
- ("thread-id={} code={} ".format(cls.random_key[code], code) + content).format(*args))
-
- @classmethod
- # 鏁版嵁澶勭悊鍏ュ彛
- # datas: 鏈鎴浘鏁版嵁
- # capture_timestamp:鎴浘鏃堕棿鎴�
- def process(cls, code, datas, capture_timestamp):
- cls.random_key[code] = random.randint(0, 100000)
- now_time_str = datetime.now().strftime("%H:%M:%S")
- __start_time = round(t.time() * 1000)
- try:
- if len(datas) > 0:
-
- # 鍒ゆ柇浠锋牸鍖洪棿鏄惁姝ｇ‘
- if not code_data_util.is_same_code_with_price(code, float(datas[0]["val"]["price"])):
- raise L2DataException(L2DataException.CODE_PRICE_ERROR,
- "鑲′环涓嶅尮閰� code-{} price-{}".format(code, datas[0]["val"]["price"]))
- # 鍔犺浇鍘嗗彶鏁版嵁
- load_l2_data(code)
- # 绾犳鏁版嵁
- datas = L2DataUtil.correct_data(code, datas)
- _start_index = 0
- if local_today_datas.get(code) is not None and len(local_today_datas[code]) > 0:
- _start_index = local_today_datas[code][-1]["index"] + 1
- add_datas = L2DataUtil.get_add_data(code, datas, _start_index)
- if len(add_datas) > 0:
- # 鎷兼帴鏁版嵁
- local_today_datas[code].extend(add_datas)
- l2_data_util.load_num_operate_map(local_today_num_operate_map, code, add_datas)
- total_datas = local_today_datas[code]
- # 杩囨椂 涔板叆纭鐐瑰鐞�
- # TradeBuyDataManager.process_buy_sure_position_info(code, capture_timestamp, total_datas,
- # total_datas[-1],
- # add_datas)
- if len(add_datas) > 0:
- _start_time = round(t.time() * 1000)
- latest_time = add_datas[len(add_datas) - 1]["val"]["time"]
- # 鏃堕棿宸笉鑳藉お澶ф墠鑳藉鐞�
- # TODO 鏆傛椂鍏抽棴澶勭悊
- # if L2DataUtil.is_same_time(now_time_str, latest_time):
- # # 鍒ゆ柇鏄惁宸茬粡鎸傚崟
- # state = trade_manager.get_trade_state(code)
- # start_index = len(total_datas) - len(add_datas)
- # end_index = len(total_datas) - 1
- # if state == trade_manager.TRADE_STATE_BUY_DELEGATED or state == trade_manager.TRADE_STATE_BUY_PLACE_ORDER:
- # # 宸叉寕鍗�
- # cls.__process_order(code, start_index, end_index, capture_timestamp)
- # else:
- # # 鏈寕鍗�
- # cls.__process_not_order(code, start_index, end_index, capture_timestamp)
- logger_l2_process.info("code:{} 澶勭悊鏁版嵁鑼冨洿: {}-{} 澶勭悊鏃堕棿:{}", code, add_datas[0]["index"],
- add_datas[-1]["index"], round(t.time() * 1000) - __start_time)
- # 淇濆瓨鏁版嵁
- save_l2_data(code, datas, add_datas)
- finally:
- if code in cls.unreal_buy_dict:
- cls.unreal_buy_dict.pop(code)
-
- @classmethod
- def __compute_big_money_data(cls, code, start_index, end_index):
- # 璁＄畻澶у崟
- total_datas = local_today_datas[code]
- num = 0
- for index in range(start_index, end_index + 1):
- data = total_datas[index]
- if l2_trade_factor.L2TradeFactorSourceDataUtil.is_big_money(data):
- if int(data["val"]["operateType"]) == 0:
- num += data["re"]
- elif int(data["val"]["operateType"]) == 1:
- num -= data["re"]
- big_money_num_manager.add_num(code, num)
-
- # 澶勭悊鏈寕鍗�
- @classmethod
- def __process_not_order(cls, code, start_index, end_index, capture_time):
- # 鑾峰彇闃堝��
- threshold_money = cls.__get_threshmoney(code)
- cls.__start_compute_buy(code, start_index, end_index, threshold_money, capture_time)
-
- @classmethod
- def __statistic_count_l2_data_for_cancel(cls, code, start_index, end_index, has_cancel_single=False):
- index, old_buy_count, old_cancel_count = TradePointManager.get_count_info_for_cancel_buy(code)
- for i in range(start_index, end_index + 1):
- buy_count, buy_cancel_count = cls.__count_l2_data_for_cancel(code, i, i)
- old_buy_count += buy_count
-
- old_cancel_count += buy_cancel_count
- if old_buy_count > 0 and (old_buy_count - old_cancel_count) / old_buy_count < 0.3 and has_cancel_single:
- return i, True
- TradePointManager.set_count_info_for_cancel_buy(code, end_index, old_buy_count,
- old_cancel_count)
- return end_index, False
-
- # 澶勭悊宸叉寕鍗�
- @classmethod
- def __process_order(cls, code, start_index, end_index, capture_time, new_add=True):
- if start_index < 0:
- start_index = 0
-
- if end_index < start_index:
- return
- # 鑾峰彇涔嬪墠鏄惁鏈夎褰曠殑鎾や拱淇″彿
- # cancel_index = TradePointManager.get_buy_cancel_single_pos(code)
-
- # cancel_computed_index, cancel_buy_num = TradePointManager.get_compute_info_for_cancel_buy(code)
- # if cancel_computed_index is None:
- # logger_l2_trade.error("{} 鏈幏鍙栧埌涔版挙绾拱棰�,璧峰璁＄畻浣嶏細{}", code, start_index)
-
- # 缁熻缇ゆ挙澶у崟
- L2BetchCancelBigNumProcessor.process_new(code, start_index, end_index)
-
- # 缁熻鏈�澶ц繛缁拱鍗�
- L2ContinueLimitUpCountManager.process(code, start_index, end_index)
-
- # 璁＄畻澶у崟鎾ら攢
- need_cancel, cancel_data = L2BigNumProcessor.process_cancel_with_big_num(code, start_index, end_index)
- if need_cancel:
- # 宸茬粡鎾ゅ崟浜�
- threshold_money = cls.__get_threshmoney(code)
- # 閲嶆柊澶勭悊涓嬪崟
- cls.__start_compute_buy(code, cancel_data["index"] + 1, end_index, threshold_money, capture_time)
- return
-
- # buy_single_index, buy_exec_index, buy_compute_index, buy_num = cls.__get_order_begin_pos(code)
- # if cancel_index is None:
- # 鏃犳挙鍗曚俊鍙疯捣濮嬬偣璁板綍
-
- continue_cancel = L2ContinueLimitUpCountManager.get_continue_count(code)
- order_cancel_begin_start = max(start_index - (continue_cancel - 1),
- 0) if new_add else start_index
- order_cancel_begin_end = end_index
- total_datas = local_today_datas[code]
-
- little_cancel = False
- # 澶у崟鎾ゅ崟鐨勬暟鎹笉涓虹┖
- if cancel_data is not None:
- # 灏忕兢鎾や簨浠�
- continue_cancel = 5
- cancel_time_seconds = L2DataUtil.get_time_as_second(cancel_data["val"]["time"])
- # 鏌ユ壘涓婁竴绉掍笌涓嬩竴绉�
- for i in range(int(cancel_data["index"]), 0, -1):
- # 鏌ユ壘涓婁竴绉掑拰涓嬩竴绉�
- if total_datas[i]["val"]["time"] != cancel_data["val"][
- "time"] and cancel_time_seconds - L2DataUtil.get_time_as_second(total_datas[i]["val"]["time"]) > 1:
- order_cancel_begin_start = i + 1
- break
-
- for i in range(int(cancel_data["index"]), len(local_today_datas[code])):
- # 鏌ユ壘涓婁竴绉掑拰涓嬩竴绉�
- if total_datas[i]["val"]["time"] != cancel_data["val"]["time"] and L2DataUtil.get_time_as_second(
- total_datas[i]["val"]["time"]) - cancel_time_seconds > 1:
- order_cancel_begin_end = i - 1
- break
- cls.cancel_debug(code, "灏忕兢鎾や簨浠惰绠楄寖鍥达細{}锛寋}", order_cancel_begin_start, order_cancel_begin_end)
- little_cancel = True
- cancel_start_index = None
- cancel_end_index = None
- need_cancel = False
- if little_cancel:
- # 灏忕兢鎾や簨浠�
- cancel_start_index, cancel_end_index = cls.__compute_order_cancel_little_begin_single(code,
- order_cancel_begin_start
- , continue_cancel,
- order_cancel_begin_end)
- if cancel_start_index is not None:
- cls.debug(code, "鎵惧埌灏忕兢鎾や俊鍙凤紝鎾ゅ崟淇″彿鑼冨洿:{}-{}", cancel_start_index, cancel_end_index)
- # 鏈夊皬缇ゆ挙淇″彿
- need_cancel = True
- else:
- # 涓嶆弧瓒冲皬缇ゆ挙,浠庡皬缇ゆ挙鍚庨潰涓�鏉℃暟鎹户缁鐞�
- cls.__process_order(code, cancel_data["index"] + 1, end_index, capture_time, False)
- return
-
- else:
- # 澶х兢鎾や簨浠�
- cancel_start_index, cancel_end_index = cls.__compute_order_cancel_begin_single(
- code, order_cancel_begin_start
- , continue_cancel, order_cancel_begin_end)
- if cancel_start_index is not None:
- cls.debug(code, "鎵惧埌澶х兢鎾や俊鍙凤紝杩炵画绗旀暟闃堝�硷細{}锛� 鎾ゅ崟淇″彿鑼冨洿:{}-{}", continue_cancel, cancel_start_index,
- cancel_end_index)
- # 鍒ゆ柇鏄惁鏈夊ぇ缇ゆ挙澶у崟鎾�
- need_cancel = L2BetchCancelBigNumProcessor.need_cancel(code, cancel_start_index, cancel_end_index)
- if need_cancel:
- cls.debug(code, "澶х兢鎾や俊鍙锋湁澶у崟鎾ら攢")
- else:
- cls.debug(code, "澶х兢鎾や俊鍙锋棤澶у崟鎾ら攢")
-
- if need_cancel:
- # 闇�瑕佹挙涔�
- cls.cancel_buy(code)
- if cancel_end_index >= end_index:
- return
- # 缁х画澶勭悊涓嬪崟淇″彿
- threshold_money = cls.__get_threshmoney(code)
- cls.__start_compute_buy(code, cancel_end_index + 1, end_index, threshold_money, capture_time, False)
-
- else:
- # 鏄惁鏈夎櫄鎷熶笅鍗�
- unreal_buy_info = cls.unreal_buy_dict.get(code)
- if unreal_buy_info is not None:
- cls.debug(code, "鏈夎櫄鎷熶笅鍗曪紝鏃犱拱鎾や俊鍙凤紝寮�濮嬫墽琛屼拱鍏ワ紝鎵ц浣嶇疆锛歿},鎴浘鏃堕棿锛歿}", unreal_buy_info[0], capture_time)
- # unreal_buy_info 鐨勫唴瀹规牸寮忎负锛�(瑙︽硶涔版搷浣滀笅鏍�,鎴浘鏃堕棿)
- # 鐪熷疄涓嬪崟
- cls.__buy(code, unreal_buy_info[1], local_today_datas[code][unreal_buy_info[0]],
- unreal_buy_info[0])
-
- # 杩囨椂 寮�濮嬭绠楁挙鐨勪俊鍙�
- @classmethod
- def __start_compute_cancel(cls, code, cancel_index, compute_start_index, origin_num, threshold_money, capture_time):
- # sure_type 0-铏氭嫙鎸備拱浣� 1-鐪熷疄鎸備拱浣�
- cancel_single = cancel_index is not None
- computed_index, buy_num_for_cancel, sure_type = cls.__sum_buy_num_for_cancel_order(code, compute_start_index,
- origin_num, threshold_money,
- cancel_single)
-
- total_datas = local_today_datas[code]
- if computed_index is not None:
- cls.debug(code, "鑾峰彇鍒版挙鍗曟墽琛屼俊鍙凤紝淇″彿浣嶇疆锛歿}锛宮2:{} 鏁版嵁锛歿}", computed_index, threshold_money,
- total_datas[computed_index])
- # 鍙戝嚭鎾や拱淇″彿锛岄渶瑕佹挙涔�
- if cls.unreal_buy_dict.get(code) is not None:
- # 鏈夎櫄鎷熶笅鍗�
- cls.debug(code, "涔嬪墠鏈夎櫄鎷熶笅鍗曪紝鎵ц铏氭嫙鎾や拱")
- # 鍒犻櫎铏氭嫙涓嬪崟鏍囪
- cls.unreal_buy_dict.pop(code)
- # 鍒犻櫎涓嬪崟鏍囪浣嶇疆
- TradePointManager.delete_buy_point(code)
- else:
- # 鏃犺櫄鎷熶笅鍗曪紝闇�瑕佹墽琛屾挙鍗�
- cls.debug(code, "涔嬪墠鏃犺櫄鎷熶笅鍗曪紝鎵ц鐪熷疄鎾ゅ崟")
- cls.__cancel_buy(code)
-
- if computed_index < len(local_today_datas[code]) - 1:
- # 鏁版嵁灏氭湭澶勭悊瀹�,閲嶆柊杩涘叆涓嬪崟璁＄畻娴佺▼
- cls.__start_compute_buy(code, computed_index + 1, threshold_money, capture_time, False)
- pass
- else:
- cls.debug(code, "鎾や拱绾拱棰濊绠楋紝璁＄畻浣嶇疆锛歿}-{}锛岀洰鍓嶄负姝㈢函涔版墜鏁帮細{}", compute_start_index, total_datas[-1]["index"],
- buy_num_for_cancel)
- # 鏃犻渶鎾や拱锛岃缃绠椾俊鎭�
- TradePointManager.set_compute_info_for_cancel_buy(code, int(total_datas[-1]["index"]), buy_num_for_cancel)
- # 鍒ゆ柇鏄惁鏈夎櫄鎷熶笅鍗�
- unreal_buy_info = cls.unreal_buy_dict.get(code)
- if unreal_buy_info is not None:
- # unreal_buy_info 鐨勫唴瀹规牸寮忎负锛�(瑙︽硶涔版搷浣滀笅鏍�,鎴浘鏃堕棿)
- # 鐪熷疄涓嬪崟
- cls.debug(code, "鏃犳挙鍗曟墽琛屼俊鍙凤紝鏈夎櫄鎷熶笅鍗曪紝鎵ц鐪熷疄涓嬪崟")
- cls.__buy(code, unreal_buy_info[1], total_datas[unreal_buy_info[0]],
- unreal_buy_info[0])
- pass
- else:
- # 缁堟鎵ц
- pass
-
- @classmethod
- def __buy(cls, code, capture_timestamp, last_data, last_data_index):
- can, reason = cls.__can_buy(code)
- # 涓嶈兘璐拱
- if not can:
- cls.debug(code, "涓嶅彲浠ヤ笅鍗曪紝鍘熷洜锛歿}", reason)
- return
- else:
- cls.debug(code, "鍙互涓嬪崟锛屽師鍥狅細{}", reason)
-
- # 鍒犻櫎铏氭嫙涓嬪崟
- if code in cls.unreal_buy_dict:
- cls.unreal_buy_dict.pop(code)
- cls.debug(code, "寮�濮嬫墽琛屼拱鍏�")
- try:
- trade_manager.start_buy(code, capture_timestamp, last_data,
- last_data_index)
- TradePointManager.delete_buy_cancel_point(code)
- cls.debug(code, "鎵ц涔板叆鎴愬姛")
- except Exception as e:
- cls.debug(code, "鎵ц涔板叆寮傚父:{}", str(e))
- pass
- finally:
- cls.debug(code, "m鍊煎奖鍝嶅洜瀛愶細", l2_trade_factor.L2TradeFactorUtil.factors_to_string(code))
-
- # 鏄惁鍙互涔�
- @classmethod
- def __can_buy(cls, code):
- limit_up_time = limit_up_time_manager.get_limit_up_time(code)
- if limit_up_time is not None and L2DataUtil.get_time_as_second(limit_up_time) >= L2DataUtil.get_time_as_second(
- "14:30:00"):
- return False, "14:30鍚庢定鍋滅殑涓嶈兘涔帮紝娑ㄥ仠鏃堕棿涓簕}".format(limit_up_time)
-
- # 鍚屼竴鏉垮潡涓�佷簩鍚庨潰鐨勪笉鑳戒拱
- industry, codes = ths_industry_util.get_same_industry_codes(code, gpcode_manager.get_gp_list())
- if industry is None:
- return True, "娌℃湁鑾峰彇鍒拌涓�"
- codes_index = industry_codes_sort.sort_codes(codes, code)
- if codes_index is not None and codes_index.get(code) is not None and codes_index.get(code) > 1:
- return False, "鍚屼竴鏉垮潡涓�佷笁,鑰佸洓,...涓嶈兘涔�"
-
- # 13:00鍚庢定鍋滐紝鏈澘鍧椾腑娑ㄥ仠绁ㄦ暟<29涓嶈兘涔�
- limit_up_time = limit_up_time_manager.get_limit_up_time(code)
- if limit_up_time is not None:
- if int(limit_up_time.replace(":", "")) >= 130000 and global_util.industry_hot_num.get(industry) is not None:
- if global_util.industry_hot_num.get(industry) < 29:
- return False, "13:00鍚庢定鍋滐紝鏈澘鍧椾腑娑ㄥ仠绁ㄦ暟<29涓嶈兘涔�"
- # 鑰佷簩锛屾湰鏉垮潡涓定鍋滅エ鏁�<29 涓嶈兘涔�
- if codes_index.get(code) is not None and codes_index.get(code) == 1 and global_util.industry_hot_num.get(
- industry) is not None:
- if global_util.industry_hot_num.get(industry) < 29:
- return False, "鑰佷簩锛屾湰鏉垮潡涓定鍋滅エ鏁�<29涓嶈兘涔�"
- # 鍙互涓嬪崟
- return True, None
-
- @classmethod
- def __cancel_buy(cls, code):
- try:
- cls.debug(code, "寮�濮嬫墽琛屾挙鍗�")
- trade_manager.start_cancel_buy(code)
- # 鍙栨秷涔板叆鏍囪瘑
- TradePointManager.delete_buy_point(code)
- TradePointManager.delete_buy_cancel_point(code)
- TradePointManager.delete_compute_info_for_cancel_buy(code)
- TradePointManager.delete_count_info_for_cancel_buy(code)
- # 鍒犻櫎澶х兢鎾や簨浠剁殑澶у崟
- L2BetchCancelBigNumProcessor.del_recod(code)
- cls.debug(code, "鎵ц鎾ゅ崟鎴愬姛")
- except Exception as e:
- logging.exception(e)
- cls.debug(code, "鎵ц鎾ゅ崟寮傚父锛歿}", str(e))
-
- @classmethod
- def cancel_buy(cls, code):
- # 鍒犻櫎澶х兢鎾や簨浠剁殑澶у崟
- L2BetchCancelBigNumProcessor.del_recod(code)
- L2ContinueLimitUpCountManager.del_data(code)
-
- if code in cls.unreal_buy_dict:
- cls.unreal_buy_dict.pop(code)
- # 鍙栨秷涔板叆鏍囪瘑
- TradePointManager.delete_buy_point(code)
- TradePointManager.delete_buy_cancel_point(code)
- TradePointManager.delete_compute_info_for_cancel_buy(code)
- TradePointManager.delete_count_info_for_cancel_buy(code)
- # 鍒犻櫎澶х兢鎾や簨浠剁殑澶у崟
- L2BetchCancelBigNumProcessor.del_recod(code)
- else:
- cls.__cancel_buy(code)
-
- L2BigNumProcessor.del_big_num_pos(code)
-
- @classmethod
- def __start_compute_buy(cls, code, compute_start_index, compute_end_index, threshold_money, capture_time,
- new_add=True):
- if compute_end_index < compute_start_index:
- return
-
- total_datas = local_today_datas[code]
- # 鑾峰彇涔板叆淇″彿璁＄畻璧峰浣嶇疆
- buy_single_index, buy_exec_index, buy_compute_index, num = cls.__get_order_begin_pos(code)
- # 鏄惁涓烘柊鑾峰彇鍒扮殑浣嶇疆
- new_get_pos = False
- if buy_single_index is None:
- # 鏈変拱鍏ヤ俊鍙�
- has_single, _index = cls.__compute_order_begin_pos(code, max(
- compute_start_index - 2 if new_add else compute_start_index, 0), 3, compute_end_index)
- buy_single_index = _index
- if has_single:
- num = 0
- new_get_pos = True
- cls.debug(code, "鑾峰彇鍒颁拱鍏ヤ俊鍙疯捣濮嬬偣锛歿} 鏁版嵁锛歿}", buy_single_index, total_datas[buy_single_index])
- limit_up_time_manager.save_limit_up_time(code, total_datas[buy_single_index]["val"]["time"])
- # 閲嶇疆澶у崟璁＄畻
- big_money_num_manager.reset(code)
- if buy_single_index is None:
- # 鏈幏鍙栧埌涔板叆淇″彿锛岀粓姝㈢▼搴�
- return None
-
- # TODO 鍙兘瀛樺湪闂 璁＄畻澶у崟鏁伴噺
- cls.__compute_big_money_data(code, max(compute_start_index, buy_single_index), compute_end_index)
- # 涔板叆绾拱棰濈粺璁�
- compute_index, buy_nums, rebegin_buy_pos = cls.__sum_buy_num_for_order_3(code, max(buy_single_index,
- compute_start_index),
- compute_end_index, num,
- threshold_money, buy_single_index,
- capture_time)
- if rebegin_buy_pos is not None:
- # 闇�瑕侀噸鏂拌绠楃函涔伴
- cls.__start_compute_buy(code, rebegin_buy_pos, compute_end_index, threshold_money, capture_time, False)
- return
-
- if compute_index is not None:
- cls.debug(code, "鑾峰彇鍒颁拱鍏ユ墽琛屼綅缃細{} m鍊硷細{} 绾拱鎵嬫暟锛歿} 鏁版嵁锛歿}", compute_index, threshold_money, buy_nums,
- total_datas[compute_index])
- # 璁板綍涔板叆淇″彿浣嶇疆
- cls.__save_order_begin_data(code, buy_single_index, compute_index, compute_index, buy_nums)
- # 铏氭嫙涓嬪崟
- cls.unreal_buy_dict[code] = (compute_index, capture_time)
- # 鍒犻櫎涔嬪墠鐨勬墍鏈夋挙鍗曚俊鍙�
- TradePointManager.delete_buy_cancel_point(code)
- TradePointManager.delete_compute_info_for_cancel_buy(code)
- TradePointManager.delete_count_info_for_cancel_buy(code)
- trade_data_manager.TradeBuyDataManager.remove_buy_position_info(code)
- # 宸茶繃鏃� 涓轰拱鎾や繚瀛樺熀纭�绾拱棰�
- # TradePointManager.set_compute_info_for_cancel_buy(code, compute_index, buy_nums)
- b_buy_count, b_buy_cancel_count = cls.__count_l2_data_before_for_cancel(code, buy_single_index)
- buy_count, buy_cancel_count = cls.__count_l2_data_for_cancel(code, buy_single_index, compute_index)
- TradePointManager.set_count_info_for_cancel_buy(code, compute_index, b_buy_count + buy_count,
- b_buy_cancel_count + buy_cancel_count)
- # 璁＄畻澶у崟(浠庝拱鍏ヤ俊鍙疯捣濮嬬偣鍒版寕鍗曟墽琛岀偣),杩斿洖鏄惁鍙栨秷
- cancel_result, cancel_data = L2BigNumProcessor.process_cancel_with_big_num(code, buy_single_index,
- compute_index)
- # 璁＄畻澶х兢鎾ょ殑澶у崟
- L2BetchCancelBigNumProcessor.process_new(code, buy_single_index, compute_index)
- # 杩炵画娑ㄥ仠鏁拌绠�
- L2ContinueLimitUpCountManager.process(code, buy_single_index, compute_index)
-
- # 鏁版嵁鏄惁澶勭悊瀹屾瘯
- if compute_index >= compute_end_index:
- cls.debug(code, "鏁版嵁澶勭悊瀹屾瘯锛屼笅鍗�, 鏁版嵁鎴浘鏃堕棿-{}", capture_time)
- # 鏁版嵁宸茬粡澶勭悊瀹屾瘯锛屽鏋滆繕娌℃挙鍗曞氨瀹為檯涓嬪崟
- if not cancel_result:
- cls.__buy(code, capture_time, total_datas[compute_index], compute_index)
- else:
- # 鏁版嵁灏氭湭澶勭悊瀹屾瘯锛岃繘琛屼笅涓�姝ュ鐞�
- cls.debug(code, "鏁版嵁灏氭湭澶勭悊瀹屾瘯锛岃繘琛屼笅涓�姝ュ鐞嗭紝澶勭悊杩涘害锛歿}", compute_index)
- # 濡傛灉杩樻病鎾ゅ崟锛屽氨缁х画澶勭悊宸蹭笅鍗曠殑姝ラ
- if not cancel_result:
- cls.__process_order(code, compute_index + 1, compute_end_index, capture_time, False)
- else:
- cls.__start_compute_buy(code, compute_index + 1, compute_end_index, threshold_money, capture_time,
- False)
- else:
- # 鏈揪鍒颁笅鍗曟潯浠讹紝淇濆瓨绾拱棰濓紝璁剧疆绾拱棰�
- # 璁板綍涔板叆淇″彿浣嶇疆
- cls.__save_order_begin_data(code, buy_single_index, -1, compute_end_index, buy_nums)
- pass
-
- # 鑾峰彇涓嬪崟璧峰淇″彿
- @classmethod
- def __get_order_begin_pos(cls, code):
- buy_single_index, buy_exec_index, compute_index, num, max_num_index = TradePointManager.get_buy_compute_start_data(
- code)
- return buy_single_index, buy_exec_index, compute_index, num, max_num_index
-
- @classmethod
- def __save_order_begin_data(self, code, buy_single_index, buy_exec_index, compute_index, num):
- TradePointManager.set_buy_compute_start_data(code, buy_single_index, buy_exec_index, compute_index, num)
-
- # 璁＄畻涓嬪崟璧峰淇″彿
- # compute_data_count 鐢ㄤ簬璁＄畻鐨刲2鏁版嵁鏁伴噺
- @classmethod
- def __compute_order_begin_pos(cls, code, start_index, continue_count, end_index):
- # 鍊掓暟100鏉℃暟鎹煡璇�
- datas = local_today_datas[code]
- if end_index - start_index + 1 < continue_count:
- return False, None
- __time = None
-
- last_index = None
- count = 0
- start = None
-
- for i in range(start_index, end_index + 1):
- _val = datas[i]["val"]
- # 鏃堕棿瑕�>=09:30:00
- if L2DataUtil.get_time_as_second(_val["time"]) < second_930:
- continue
-
- if L2DataUtil.is_limit_up_price_buy(_val) and (last_index is None or (
- i - last_index == 1 and datas[last_index]["val"]["time"] == datas[i]["val"]["time"])):
- if start is None:
- start = i
- last_index = i
- count += datas[i]["re"]
- if count >= continue_count:
- return True, start
- elif not L2DataUtil.is_limit_up_price_sell(_val):
- last_index = None
- count = 0
- start = None
-
- return False, None
-
- # 澶х兢鎾や簨浠�,鏈�澶氱浉闅�1s
- @classmethod
- def __compute_order_cancel_begin_single(cls, code, start_index, continue_count, end_index):
- datas = local_today_datas[code]
- if end_index - start_index + 1 < continue_count:
- return None, None
- count = 0
- start = -1
- start_time = None
- for i in range(start_index, end_index + 1):
- _val = datas[i]["val"]
- _timestamp = L2DataUtil.get_time_as_second(_val["time"])
- if L2DataUtil.get_time_as_second(_val["time"]) < second_930:
- continue
- if L2DataUtil.is_limit_up_price_buy_cancel(_val) and (start_time is None or _timestamp - start_time < 2):
- if start == -1:
- start = i
- start_time = L2DataUtil.get_time_as_second(_val["time"])
- count += datas[i]["re"]
- elif not L2DataUtil.is_limit_up_price_sell(_val):
- if count >= continue_count:
- return start, i - 1
- start = -1
- count = 0
- start_time = None
- if count >= continue_count:
- return start, end_index
- else:
- return None, None
-
- # 灏忕兢鎾や簨浠�
- @classmethod
- def __compute_order_cancel_little_begin_single(cls, code, start_index, continue_count, end_index=None):
- # 蹇呴』涓哄悓涓�绉掔殑鏁版嵁
- same_second = True
- datas = local_today_datas[code]
- __len = len(datas)
- if len(datas) - start_index < continue_count:
- return None, None
- count = 0
- start = -1
- start_time = None
- if end_index is None:
- end_index = __len - continue_count
- for i in range(start_index, end_index + 1):
- _val = datas[i]["val"]
- _timestamp = L2DataUtil.get_time_as_second(_val["time"])
- if _timestamp < second_930:
- continue
- # 闂撮殧鏃堕棿涓嶈兘澶氫簬1s
- if L2DataUtil.is_limit_up_price_buy_cancel(_val) and (start_time is None or _timestamp - start_time < 2):
- if start == -1:
- start = i
- start_time = L2DataUtil.get_time_as_second(_val["time"])
- count += int(datas[i]["re"])
- elif not L2DataUtil.is_limit_up_price_sell(_val):
- if count >= continue_count:
- return start, i - 1
- start = -1
- count = 0
- start_time = None
- if count >= continue_count:
- return start, end_index
- else:
- return None, None
-
- # 铏氭嫙涓嬪崟
- def __unreal_order(self):
- pass
-
- @classmethod
- def __get_threshmoney(cls, code):
- money, msg = l2_trade_factor.L2TradeFactorUtil.compute_m_value(code)
- return money
-
- # 鑾峰彇棰勪及鎸備拱浣�
- @classmethod
- def __get_sure_order_pos(cls, code):
- index, data = trade_data_manager.TradeBuyDataManager.get_buy_sure_position(code)
- if index is None:
- return 0, len(local_today_datas[code]) - 1, local_today_datas[code][-1]
- else:
- return 1, index, data
-
- # 杩囨椂 缁熻涔板叆鍑�涔伴噺
- @classmethod
- def __sum_buy_num_for_order(cls, code, compute_start_index, origin_num, threshold_money):
- total_datas = local_today_datas[code]
- buy_nums = origin_num
- limit_up_price = gpcode_manager.get_limit_up_price(code)
- if limit_up_price is None:
- raise Exception("娑ㄥ仠浠锋棤娉曡幏鍙�")
- threshold_num = threshold_money / (limit_up_price * 100)
- for i in range(compute_start_index, len(total_datas)):
- _val = total_datas[i]["val"]
- # 鏈夎繛缁�4涓定鍋滀拱灏辨爣璁拌绠楄捣濮嬬偣
- if L2DataUtil.is_limit_up_price_buy(_val):
- # 娑ㄥ仠涔�
- buy_nums += int(_val["num"]) * int(total_datas[i]["re"])
- if buy_nums >= threshold_num:
- cls.debug(code, "鑾峰彇鍒颁拱鍏ユ墽琛岀偣锛歿} 缁熻绾拱鎵嬫暟锛歿} 鐩爣绾拱鎵嬫暟锛歿}", i, buy_nums, threshold_num)
- return i, buy_nums
- elif L2DataUtil.is_limit_up_price_buy_cancel(_val):
- # 娑ㄥ仠涔版挙
- buy_nums -= int(_val["num"]) * int(total_datas[i]["re"])
- cls.debug(code, "灏氭湭鑾峰彇鍒颁拱鍏ユ墽琛岀偣锛岃捣濮嬭绠椾綅缃細{} 缁熻绾拱鎵嬫暟锛歿} 鐩爣绾拱鎵嬫暟锛歿}", compute_start_index, buy_nums,
- threshold_num)
- return None, buy_nums
-
- # 杩囨椂 缁熻涔板叆鍑�涔伴噺锛屼笉璁＄畻鍦ㄤ拱鍏ヤ俊鍙蜂箣鍓嶇殑涔版挙鍗�
- @classmethod
- def __sum_buy_num_for_order_2(cls, code, compute_start_index, origin_num, threshold_money, buy_single_index):
- total_datas = local_today_datas[code]
- buy_nums = origin_num
- limit_up_price = gpcode_manager.get_limit_up_price(code)
- if limit_up_price is None:
- raise Exception("娑ㄥ仠浠锋棤娉曡幏鍙�")
- threshold_num = threshold_money / (limit_up_price * 100)
- property_buy_num_count = 0
- same_time_property = cls.__get_same_time_property(code)
- for i in range(compute_start_index, len(total_datas)):
- data = total_datas[i]
- _val = total_datas[i]["val"]
- # 鏈夎繛缁�4涓定鍋滀拱灏辨爣璁拌绠楄捣濮嬬偣
- if L2DataUtil.is_limit_up_price_buy(_val):
- # 娑ㄥ仠涔�
- buy_nums += int(_val["num"]) * int(total_datas[i]["re"])
- if buy_nums >= threshold_num:
- logger_l2_trade_buy.info("{}鑾峰彇鍒颁拱鍏ユ墽琛岀偣锛歿} 缁熻绾拱鎵嬫暟锛歿} 鐩爣绾拱鎵嬫暟锛歿}", code, i, buy_nums, threshold_num)
- elif L2DataUtil.is_limit_up_price_buy_cancel(_val):
- # 娑ㄥ仠涔版挙
- # 鍒ゆ柇涔板叆浣嶇疆鏄惁鍦ㄤ拱鍏ヤ俊鍙蜂箣鍓�
- buy_index, buy_data = l2_data_util.get_buy_data_with_cancel_data(total_datas[i],
- local_today_num_operate_map.get(code))
- if buy_index is not None:
- # 鎵惧埌涔版挙鏁版嵁鐨勪拱鍏ョ偣
- if buy_index >= buy_single_index:
- buy_nums -= int(_val["num"]) * int(data["re"])
- cls.buy_debug(code, "{}鏁版嵁鍦ㄤ拱鍏ヤ俊鍙蜂箣鍚� 鎾や拱绾拱鎵嬫暟锛歿} 鐩爣鎵嬫暟锛歿}", i, buy_nums, threshold_num)
- else:
- cls.buy_debug(code, "{}鏁版嵁鍦ㄤ拱鍏ヤ俊鍙蜂箣鍓嶏紝涔板叆浣嶏細{}", i, buy_index)
- if total_datas[buy_single_index]["val"]["time"] == buy_data["val"]["time"]:
- # 鍚屼竴绉�,鑰屼笖杩樺湪棰勪及涔板叆浣嶄箣鍚庢寜姒傜巼璁＄畻
- property_buy_num_count -= int(_val["num"]) * int(data["re"])
- cls.buy_debug(code, "{}鏁版嵁涔板叆浣嶄笌棰勪及涔板叆浣嶅湪鍚屼竴绉�", i)
- else:
- # 鏈壘鍒颁拱鎾ゆ暟鎹殑涔板叆鐐�
- cls.cancel_debug(code, "鏈壘鍒颁拱鎾ゆ暟鎹殑涔板叆鐐�: 浣嶇疆-{} 鏁版嵁-{}", i, data)
- buy_nums -= int(_val["num"]) * int(total_datas[i]["re"])
- property_buy_num = round(property_buy_num_count * same_time_property)
- cls.buy_debug(code, "涔板叆淇″彿鐐逛箣鍓嶅悓涓�绉掍拱鍏ユ墜鏁�-{}锛屼綅缃�-{}锛屾�绘墜鏁帮細{}锛岀洰鏍囨墜鏁帮細{}", property_buy_num, i,
- buy_nums + property_buy_num, threshold_num)
- # 鏈夋挙鍗曚俊鍙凤紝涓斿皬浜庨槇鍊�
- if buy_nums + property_buy_num >= threshold_num:
- return i, buy_nums + property_buy_num
-
- cls.buy_debug(code, "灏氭湭鑾峰彇鍒颁拱鍏ユ墽琛岀偣锛岃捣濮嬭绠椾綅缃細{} 缁熻绾拱鎵嬫暟锛歿} 鐩爣绾拱鎵嬫暟锛歿}", compute_start_index,
- buy_nums + property_buy_num,
- threshold_num)
- return None, buy_nums + property_buy_num
-
- # 缁熻涔板叆鍑�涔伴噺锛屼笉璁＄畻鍦ㄤ拱鍏ヤ俊鍙蜂箣鍓嶇殑涔版挙鍗�
- @classmethod
- def __sum_buy_num_for_order_3(cls, code, compute_start_index, compute_end_index, origin_num, threshold_money,
- buy_single_index,
- capture_time):
- total_datas = local_today_datas[code]
- buy_nums = origin_num
- limit_up_price = gpcode_manager.get_limit_up_price(code)
- if limit_up_price is None:
- raise Exception("娑ㄥ仠浠锋棤娉曡幏鍙�")
- threshold_num = threshold_money / (limit_up_price * 100)
- buy_single_time_seconds = L2DataUtil.get_time_as_second(total_datas[buy_single_index]["val"]["time"])
- for i in range(compute_start_index, compute_end_index + 1):
- data = total_datas[i]
- _val = total_datas[i]["val"]
- if L2DataUtil.get_time_as_second(_val["time"]) - buy_single_time_seconds > 1:
- TradePointManager.delete_buy_point(code)
- if i == compute_end_index:
- # 鏁版嵁澶勭悊瀹屾瘯
- return None, buy_nums, None
- else:
- # 璁＄畻涔板叆淇″彿锛屼笉鑳藉悓涓�鏃堕棿寮�濮嬭绠�
- for ii in range(buy_single_index + 1, compute_end_index + 1):
- if total_datas[buy_single_index]["val"]["time"] != total_datas[ii]["val"]["time"]:
- return None, buy_nums, ii
-
- # 娑ㄥ仠涔�
- if L2DataUtil.is_limit_up_price_buy(_val):
- # 娑ㄥ仠涔�
- buy_nums += int(_val["num"]) * int(total_datas[i]["re"])
- if buy_nums >= threshold_num:
- logger_l2_trade_buy.info("{}鑾峰彇鍒颁拱鍏ユ墽琛岀偣锛歿} 缁熻绾拱鎵嬫暟锛歿} 鐩爣绾拱鎵嬫暟锛歿}", code, i, buy_nums, threshold_num)
- elif L2DataUtil.is_limit_up_price_buy_cancel(_val):
- # 娑ㄥ仠涔版挙
- # 鍒ゆ柇涔板叆浣嶇疆鏄惁鍦ㄤ拱鍏ヤ俊鍙蜂箣鍓�
- buy_index, buy_data = l2_data_util.get_buy_data_with_cancel_data(total_datas[i],
- local_today_num_operate_map.get(code))
- if buy_index is not None:
- # 鎵惧埌涔版挙鏁版嵁鐨勪拱鍏ョ偣
- if buy_index >= buy_single_index:
- buy_nums -= int(_val["num"]) * int(data["re"])
- cls.buy_debug(code, "{}鏁版嵁鍦ㄤ拱鍏ヤ俊鍙蜂箣鍚� 鎾や拱绾拱鎵嬫暟锛歿} 鐩爣鎵嬫暟锛歿}", i, buy_nums, threshold_num)
- else:
- cls.buy_debug(code, "{}鏁版嵁鍦ㄤ拱鍏ヤ俊鍙蜂箣鍓嶏紝涔板叆浣嶏細{}", i, buy_index)
- if total_datas[buy_single_index]["val"]["time"] == buy_data["val"]["time"]:
- # 鍚屼竴绉�,褰撲綔涔板叆淇″彿涔嬪悗澶勭悊
- buy_nums -= int(_val["num"]) * int(data["re"])
- cls.buy_debug(code, "{}鏁版嵁涔板叆浣嶄笌棰勪及涔板叆浣嶅湪鍚屼竴绉�", i)
- else:
- # 鏈壘鍒颁拱鎾ゆ暟鎹殑涔板叆鐐�
- cls.buy_debug(code, "鏈壘鍒颁拱鎾ゆ暟鎹殑涔板叆鐐�: 浣嶇疆-{} 鏁版嵁-{}", i, data)
- buy_nums -= int(_val["num"]) * int(total_datas[i]["re"])
- cls.buy_debug(code, "浣嶇疆-{}锛屾�绘墜鏁帮細{}锛岀洰鏍囨墜鏁帮細{}", i,
- buy_nums, threshold_num)
- # 鏈夋挙鍗曚俊鍙凤紝涓斿皬浜庨槇鍊�
- if buy_nums >= threshold_num:
- return i, buy_nums, None
-
- cls.buy_debug(code, "灏氭湭鑾峰彇鍒颁拱鍏ユ墽琛岀偣锛岃捣濮嬭绠椾綅缃細{} 缁熻绾拱鎵嬫暟锛歿} 鐩爣绾拱鎵嬫暟锛歿}", compute_start_index,
- buy_nums,
- threshold_num)
- return None, buy_nums, None
-
- # 璁＄畻涔板叆淇″彿涔嬪墠鐨勪笖鍜屼拱鍏ヤ俊鍙锋暟鎹湪鍚屼竴鏃堕棿鐨勬暟閲�
- @classmethod
- def __count_l2_data_before_for_cancel(cls, code, buy_single_index):
- total_data = local_today_datas[code]
- single_time = total_data[buy_single_index]["val"]["time"]
- buy_count = 0
- cancel_count = 0
- for i in range(buy_single_index, -1, -1):
- if single_time == total_data[i]["val"]["time"]:
- if L2DataUtil.is_limit_up_price_buy(total_data[i]["val"]):
- buy_count += int(total_data[i]["re"])
- elif L2DataUtil.is_limit_up_price_buy(total_data[i]["val"]):
- cancel_count += int(total_data[i]["re"])
- else:
- break
- return buy_count, cancel_count
-
- @classmethod
- def __count_l2_data_for_cancel(cls, code, start_index, end_index):
- total_data = local_today_datas[code]
- buy_count = 0
- cancel_count = 0
- for i in range(start_index, end_index + 1):
- if L2DataUtil.is_limit_up_price_buy(total_data[i]["val"]):
- buy_count += int(total_data[i]["re"])
- elif L2DataUtil.is_limit_up_price_buy_cancel(total_data[i]["val"]):
- cancel_count += int(total_data[i]["re"])
- return buy_count, cancel_count
-
- # 鍚屼竴鏃堕棿涔板叆鐨勬鐜囪绠�
- @classmethod
- def __get_same_time_property(cls, code):
- # 璁＄畻鏉垮潡鐑害
- industry = global_util.code_industry_map.get(code)
- if industry is not None:
- hot_num = global_util.industry_hot_num.get(industry)
- if hot_num is not None:
- return 1 - l2_trade_factor.L2TradeFactorUtil.get_industry_rate(hot_num)
- return 0.5
-
- # 杩囨椂 缁熻涔版挙鍑�涔伴噺
- @classmethod
- def __sum_buy_num_for_cancel_order(cls, code, start_index, origin_num, threshold_money, cancel_single=True):
- buy_nums = origin_num
- total_datas = local_today_datas[code]
- limit_up_price = gpcode_manager.get_limit_up_price(code)
- if limit_up_price is None:
- raise Exception("娑ㄥ仠浠锋棤娉曡幏鍙�")
- threshold_num = threshold_money / (limit_up_price * 100)
- # 鑾峰彇棰勪及鎸備拱浣� sure_type:0 铏氭嫙鎸備拱 1 瀹為檯鎸備拱
- sure_type, sure_pos, sure_data = cls.__get_sure_order_pos(code)
- same_time_property = cls.__get_same_time_property(code)
- # 鍚屼竴绉掞紝鍦ㄩ浼颁拱鍏ヤ綅涔嬪悗鐨勬暟鎹箣鍜�
- property_buy_num_count = 0
- cls.cancel_debug(code, "鎾ゅ崟绾拱棰濊绠椾綅缃細{}-{} 棰勪及鎸備拱浣嶏細{} 鏄惁鏈夋挙鍗曚俊鍙凤細{}", start_index, len(total_datas) - 1, sure_pos,
- cancel_single)
- for i in range(start_index, len(total_datas)):
- data = total_datas[i]
- _val = data["val"]
- if L2DataUtil.is_limit_up_price_buy(_val):
- # 娑ㄥ仠涔�
- if i < sure_pos:
- buy_nums += int(_val["num"]) * int(data["re"])
- elif sure_data["val"]["time"] == _val["time"]:
- # 鍚屼竴绉掍拱鍏ワ紝鑰屼笖杩樺湪棰勪及涔板叆浣嶄箣鍚�
- property_buy_num_count += int(_val["num"]) * int(data["re"])
-
- elif L2DataUtil.is_limit_up_price_buy_cancel(_val):
- # 娑ㄥ仠鎾や拱
- # 鍒ゆ柇涔板叆浣嶇疆鏄惁鍦ㄤ拱鍏ヤ俊鍙蜂箣鍓�
- buy_index, buy_data = l2_data_util.get_buy_data_with_cancel_data(data,
- local_today_num_operate_map.get(code))
- if buy_index is not None:
- # 鎵惧埌涔版挙鏁版嵁鐨勪拱鍏ョ偣
- if buy_index < sure_pos:
- buy_nums -= int(_val["num"]) * int(data["re"])
- cls.cancel_debug(code, "{}鏁版嵁鍦ㄩ浼颁拱鍏ヤ綅涔嬪墠 鎾や拱绾拱鎵嬫暟锛歿} 鐩爣鎵嬫暟锛歿}", i, buy_nums, threshold_num)
- else:
- cls.cancel_debug(code, "{}鏁版嵁鍦ㄩ浼颁拱鍏ヤ綅涔嬪悗锛屼拱鍏ヤ綅锛歿}", i, buy_index)
- if sure_data["val"]["time"] == buy_data["val"]["time"]:
- # 鍚屼竴绉�,鑰屼笖杩樺湪棰勪及涔板叆浣嶄箣鍚庢寜姒傜巼璁＄畻
- property_buy_num_count -= int(_val["num"]) * int(data["re"])
- cls.debug(code, "{}鏁版嵁涔板叆浣嶄笌棰勪及涔板叆浣嶅湪鍚屼竴绉�", i)
- else:
- # 鏈壘鍒颁拱鎾ゆ暟鎹殑涔板叆鐐�
- cls.cancel_debug(code, "鏈壘鍒颁拱鎾ゆ暟鎹殑涔板叆鐐�: 浣嶇疆-{} 鏁版嵁-{}", i, data)
-
- property_buy_num = round(property_buy_num_count * same_time_property)
- cls.cancel_debug(code, "棰勪及涔板叆鐐逛箣鍚庡悓涓�绉掍拱鍏ユ墜鏁�-{}锛屼綅缃�-{}锛屾�绘墜鏁帮細{}锛岀洰鏍囨墜鏁帮細{}", property_buy_num, i,
- buy_nums + property_buy_num, threshold_num)
- # 鏈夋挙鍗曚俊鍙凤紝涓斿皬浜庨槇鍊�
- if buy_nums + property_buy_num <= threshold_num and cancel_single:
- return i, buy_nums + property_buy_num, sure_type
- buy_num_news = buy_nums + round(property_buy_num_count * same_time_property)
- cls.cancel_debug(code, "澶勭悊璧峰浣嶇疆锛歿} 鏈�缁堢函涔伴锛歿}", start_index, buy_num_news)
- return None, buy_num_news, sure_type
-
- # 缁熻涔版挙鍑�涔伴噺
-
- @classmethod
- def __count_num_for_cancel_order(cls, code, start_index, origin_buy_num, origin_cancel_num, min_rate,
- betch_cancel_single=True):
- buy_nums = origin_buy_num
- buy_cancel_num = origin_cancel_num
- total_datas = local_today_datas[code]
- limit_up_price = gpcode_manager.get_limit_up_price(code)
- if limit_up_price is None:
- raise Exception("娑ㄥ仠浠锋棤娉曡幏鍙�")
- # 鑾峰彇棰勪及鎸備拱浣� sure_type:0 铏氭嫙鎸備拱 1 瀹為檯鎸備拱
- for i in range(start_index, len(total_datas)):
- data = total_datas[i]
- _val = data["val"]
- if L2DataUtil.is_limit_up_price_buy(_val):
- # 娑ㄥ仠涔�
- buy_nums += int(data["re"])
- elif L2DataUtil.is_limit_up_price_buy_cancel(_val):
- buy_cancel_num += int(data["re"])
- # 鏈夋挙鍗曚俊鍙凤紝涓斿皬浜庨槇鍊�
- if (buy_nums - buy_cancel_num) / buy_cancel_num <= min_rate and betch_cancel_single:
- return i, buy_nums, buy_cancel_num
- return None, buy_nums, buy_cancel_num
-
- @classmethod
- def test(cls):
- code = "000593"
- load_l2_data(code, True)
-
- if False:
- state = trade_manager.get_trade_state(code)
- cls.random_key[code] = random.randint(0, 100000)
- capture_timestamp = 1999988888
- try:
- if state == trade_manager.TRADE_STATE_BUY_DELEGATED or state == trade_manager.TRADE_STATE_BUY_PLACE_ORDER:
- # 宸叉寕鍗�
- cls.__process_order(code, 201, 237, capture_timestamp)
- else:
- # 鏈寕鍗�
- cls.__process_not_order(code, 201, 237, capture_timestamp)
- except Exception as e:
- logging.exception(e)
- return
-
- _start = t.time()
- # 鎸塻鎵归噺鍖栨暟鎹�
- total_datas = local_today_datas[code]
- start_time = total_datas[0]["val"]["time"]
- start_index = 0
- for i in range(0, len(total_datas)):
- if total_datas[i]["val"]["time"] != start_time:
- cls.random_key[code] = random.randint(0, 100000)
- # 澶勭悊鏁版嵁
- start = start_index
- # if start != 201:
- # continue
- end = i - 1
- print("澶勭悊杩涘害锛歿},{}".format(start, end))
- capture_timestamp = 1999999999
- state = trade_manager.get_trade_state(code)
- try:
- if state == trade_manager.TRADE_STATE_BUY_DELEGATED or state == trade_manager.TRADE_STATE_BUY_PLACE_ORDER:
- # 宸叉寕鍗�
- cls.__process_order(code, start, end, capture_timestamp)
- else:
- # 鏈寕鍗�
- cls.__process_not_order(code, start, end, capture_timestamp)
- except Exception as e:
- logging.exception(e)
- # t.sleep(1)
- start_index = i
- start_time = total_datas[i]["val"]["time"]
-
- print("鏃堕棿鑺辫垂:", round((t.time() - _start) * 1000))
-
- @classmethod
- def test1(cls):
- code = "000593"
- load_l2_data(code, True)
- print(cls.__compute_order_begin_pos(code, 232, 3, 239))
-
- @classmethod
- def test2(cls):
- code = "600082"
- load_l2_data(code, True)
- cls.random_key[code] = random.randint(0, 100000)
- need_cancel, cancel_data = L2BigNumProcessor.process_cancel_with_big_num(code, 121, 123)
-
- @classmethod
- def test_can_order(cls):
- code = "000948"
-
- global_data_loader.load_industry()
- limit_up_time_manager.load_limit_up_time()
- print(cls.__can_buy(code))
-
# 杩炵画娑ㄥ仠涔板崟鏁版渶澶у�肩鐞嗗櫒
class L2ContinueLimitUpCountManager:
--
Gitblit v1.8.0