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_new.py | 88 ++--
constant.py | 2
trade_gui.py | 6
data_export_util.py | 2
ocr_util.py | 28 +
l2_data_util.py | 2
server.py | 10
trade_data_manager.py | 12
juejin.py | 2
trade_manager.py | 6
ths_industry_util.py | 2
l2_data_manager.py | 931 ------------------------------------------------
l2_trade_test.py | 11
13 files changed, 107 insertions(+), 995 deletions(-)
diff --git a/constant.py b/constant.py
index deb29e2..d2c2fc5 100644
--- a/constant.py
+++ b/constant.py
@@ -1,7 +1,7 @@
# 鏄惁涓烘祴璇�
TEST = True
# 姘翠笅鎹炵疮璁¤繛缁按涓嬫椂闂存渶灏忓��
-UNDER_WATER_PRICE_TIME_AS_SECONDS = 600
+UNDER_WATER_PRICE_TIME_AS_SECONDS = 1200
# 澶у崟閲戦锛堝崟浣嶄负鐧撅級
BIG_MONEY_AMOUNT = 29900
# 澶у崟绗旀暟
diff --git a/data_export_util.py b/data_export_util.py
index 0c16064..aef6731 100644
--- a/data_export_util.py
+++ b/data_export_util.py
@@ -193,6 +193,6 @@
if __name__ == "__main__":
- codes = ["002043"]
+ codes = ["002363"]
for code in codes:
export_l2_excel(code)
diff --git a/juejin.py b/juejin.py
index 3c4fe8f..e186d90 100644
--- a/juejin.py
+++ b/juejin.py
@@ -262,7 +262,7 @@
# 閲囬泦鐨勪唬鐮佹暟閲忎笉瀵�
if len(gpcode_manager.get_gp_list()) - len(prices) > 2:
return
- now_str = datetime.datetime.now().strftime("%H:%M:%S")
+ now_str = tool.get_now_time_str()
now_strs = now_str.split(":")
now_second = int(now_strs[0]) * 60 * 60 + int(now_strs[1]) * 60 + int(now_strs[2])
start = 60 * 60 * 9 + 31 * 60
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:
diff --git a/l2_data_manager_new.py b/l2_data_manager_new.py
index 279b9c5..8a55c4f 100644
--- a/l2_data_manager_new.py
+++ b/l2_data_manager_new.py
@@ -211,7 +211,7 @@
@classmethod
def process_add_datas(cls, code, add_datas, capture_timestamp, __start_time):
if len(add_datas) > 0:
- now_time_str = datetime.datetime.now().strftime("%H:%M:%S")
+ now_time_str = tool.get_now_time_str()
# 鎷兼帴鏁版嵁
local_today_datas[code].extend(add_datas)
l2_data_util.load_num_operate_map(l2_data_manager.local_today_num_operate_map, code, add_datas)
@@ -301,7 +301,7 @@
if end_index < start_index:
return
# 鑾峰彇涔板叆淇″彿璧峰鐐�
- buy_single_index, buy_exec_index, buy_compute_index, num, count, max_num_index = cls.__get_order_begin_pos(
+ buy_single_index, buy_exec_index, buy_compute_index, num, count, max_num_set = cls.__get_order_begin_pos(
code)
# 鎾ゅ崟璁＄畻,鍙湅涔�1
@@ -390,7 +390,7 @@
trade_data_manager.placeordercountmanager.place_order(code)
# 鑾峰彇涔板叆浣嶇疆淇℃伅
try:
- buy_single_index, buy_exec_index, buy_compute_index, num, count, max_num_index = cls.__get_order_begin_pos(
+ buy_single_index, buy_exec_index, buy_compute_index, num, count, max_num_set = cls.__get_order_begin_pos(
code)
SecondAverageBigNumComputer.place_order_success(code, buy_single_index, buy_exec_index)
AverageBigNumComputer.place_order_success(code, buy_single_index, buy_exec_index)
@@ -450,13 +450,14 @@
# if abs(float(buy1_price) - float(limit_up_price)) >= 0.01:
# return False, "涔�1浠蜂笉涓烘定鍋滀环锛屼拱1浠�-{} 娑ㄥ仠浠�-{}".format(buy1_price, limit_up_price)
# 浠庝拱鍏ヤ俊鍙疯捣濮嬬偣鍒板綋鍓嶆暟鎹湯灏剧殑绾拱鎵嬫暟涓庡綋鍓嶇殑鍗�1鍋氭瘮杈冿紝濡傛灉姣斿崠1灏忓垯涓嶈兘涔板叆
+ total_datas = local_today_datas[code]
try:
sell1_time, sell1_price, sell1_volumn = cls.__ths_l2_trade_queue_manager.get_sell1_info(code)
cls.buy_debug(code, "鍗�1淇℃伅涓猴細({},{},{})", sell1_time, sell1_price, sell1_volumn)
if sell1_time is not None and sell1_volumn > 0:
# 鑾峰彇鎵ц浣嶄俊鎭�
- total_datas = local_today_datas[code]
- buy_single_index, buy_exec_index, buy_compute_index, num, count, max_num_index = cls.__get_order_begin_pos(
+
+ buy_single_index, buy_exec_index, buy_compute_index, num, count, max_num_set = cls.__get_order_begin_pos(
code)
buy_nums = num
for i in range(buy_exec_index + 1, total_datas[-1]["index"] + 1):
@@ -491,23 +492,25 @@
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, "鍚屼竴鏉垮潡涓�佷笁,鑰佸洓,...涓嶈兘涔�"
- if cls.__codeActualPriceProcessor.is_under_water(code):
+ if cls.__codeActualPriceProcessor.is_under_water(code,total_datas[-1]["val"]["time"]):
# 姘翠笅鎹炰笖鏉垮潡涓殑绁ㄥ皬浜�16涓嶈兘涔�
- if global_util.industry_hot_num.get(industry) is not None and global_util.industry_hot_num.get(
- industry) <= 16:
- return False, "姘翠笅鎹�,鏉垮潡涓殑绁ㄥ皬浜�2鍙�,涓簕}".format(global_util.industry_hot_num.get(industry))
-
+ # if global_util.industry_hot_num.get(industry) is not None and global_util.industry_hot_num.get(
+ # industry) <= 16:
+ # return False, "姘翠笅鎹�,鏉垮潡涓殑绁ㄥ皬浜�2鍙�,涓簕}".format(global_util.industry_hot_num.get(industry))
+ # 姘翠笅鎹炶嚜鐢辨祦閫氬競鍊煎ぇ浜庤�佸ぇ鐨勪笉瑕佷拱
if codes_index.get(code) != 0:
- return False, "姘翠笅鎹�,涓嶆槸鑰佸ぇ锛屾槸鑰亄}".format(codes_index.get(code))
+ # 鑾峰彇鑰佸ぇ鐨勫競鍊�
+ for c in codes_index:
+ if codes_index.get(c) == 0 and global_util.zyltgb_map.get(code) > global_util.zyltgb_map.get(c):
+ return False, "姘翠笅鎹烇紝涓嶆槸鑰佸ぇ锛屼笖鑷敱娴侀�氬競鍊煎ぇ浜庤�佸ぇ"
# 13:30鍚庢定鍋滐紝鏈澘鍧椾腑娑ㄥ仠绁ㄦ暟<29涓嶈兘涔�
- if limit_up_time is not None:
- if int(limit_up_time.replace(":", "")) >= 133000 and global_util.industry_hot_num.get(industry) is not None:
- if global_util.industry_hot_num.get(industry) < 16:
- return False, "13:30鍚庢定鍋滐紝鏈澘鍧椾腑娑ㄥ仠绁ㄦ暟<16涓嶈兘涔�"
+ # if limit_up_time is not None:
+ # if int(limit_up_time.replace(":", "")) >= 133000 and global_util.industry_hot_num.get(industry) is not None:
+ # if global_util.industry_hot_num.get(industry) < 16:
+ # return False, "13:30鍚庢定鍋滐紝鏈澘鍧椾腑娑ㄥ仠绁ㄦ暟<16涓嶈兘涔�"
if codes_index.get(code) is not None and codes_index.get(code) == 1:
# 濡傛灉鑰佸ぇ宸茬粡涔版垚鍔熶簡, 鑰佷簩灏变笉闇�瑕佷拱浜�
@@ -561,11 +564,11 @@
# 鏄惁鏄氦鏄撻槦鍒楄Е鍙�
if source == "trade_queue":
# 浜ゆ槗闃熷垪瑙﹀彂鐨勯渶瑕佷笅鍗曞悗5s
- buy_single_index, buy_exec_index, buy_compute_index, num, count, max_num_index = cls.__get_order_begin_pos(
+ buy_single_index, buy_exec_index, buy_compute_index, num, count, max_num_set = cls.__get_order_begin_pos(
code)
total_datas = local_today_datas[code]
if buy_exec_index is not None and buy_exec_index > 0:
- now_time_str = datetime.datetime.now().strftime("%H:%M:%S")
+ now_time_str = tool.get_now_time_str()
if tool.trade_time_sub(now_time_str, total_datas[buy_exec_index]["val"]["time"]) < 5:
return False
@@ -607,7 +610,7 @@
_start_time = round(t.time() * 1000)
total_datas = local_today_datas[code]
# 鑾峰彇涔板叆淇″彿璁＄畻璧峰浣嶇疆
- buy_single_index, buy_exec_index, buy_compute_index, num, count, max_num_index = cls.__get_order_begin_pos(
+ buy_single_index, buy_exec_index, buy_compute_index, num, count, max_num_set = cls.__get_order_begin_pos(
code)
# 鏄惁涓烘柊鑾峰彇鍒扮殑浣嶇疆
@@ -643,16 +646,7 @@
threshold_money, msg = cls.__get_threshmoney(code)
# 涔板叆绾拱棰濈粺璁�
- compute_index, buy_nums, buy_count, rebegin_buy_pos, max_num_index_new = cls.__sum_buy_num_for_order_3(code,
- max(
- buy_single_index,
- compute_start_index),
- compute_end_index,
- num,
- count,
- threshold_money,
- buy_single_index,
- max_num_index)
+ compute_index, buy_nums, buy_count, rebegin_buy_pos, max_num_set_new = cls.__sum_buy_num_for_order_3(code, max(buy_single_index,compute_start_index),compute_end_index,num,count,threshold_money,buy_single_index,max_num_set)
_start_time = l2_data_log.l2_time(code, round(t.time() * 1000) - _start_time, "绾拱棰濈粺璁℃椂闂�")
cls.debug(code, "m鍊�-{} m鍊煎洜瀛�-{}", threshold_money, msg)
@@ -669,7 +663,7 @@
total_datas[compute_index])
# 璁板綍涔板叆淇″彿浣嶇疆
cls.__save_order_begin_data(code, buy_single_index, compute_index, compute_index, buy_nums, buy_count,
- max_num_index_new)
+ max_num_set_new)
# 濡傛灉鏄粖澶╃涓�娆℃湁涓嬪崟鎵ц淇″彿锛屾定鍋滄椂闂达紙涔板叆鎵ц浣嶆椂闂达級
limit_up_time_manager.save_limit_up_time(code, total_datas[compute_index]["val"]["time"])
# 铏氭嫙涓嬪崟
@@ -714,7 +708,7 @@
# 鏈揪鍒颁笅鍗曟潯浠讹紝淇濆瓨绾拱棰濓紝璁剧疆绾拱棰�
# 璁板綍涔板叆淇″彿浣嶇疆
cls.__save_order_begin_data(code, buy_single_index, -1, compute_end_index, buy_nums, buy_count,
- max_num_index_new)
+ max_num_set_new)
print("淇濆瓨澶у崟鏃堕棿", round((t.time() - _start_time) * 1000))
_start_time = t.time()
pass
@@ -722,15 +716,15 @@
# 鑾峰彇涓嬪崟璧峰淇″彿
@classmethod
def __get_order_begin_pos(cls, code):
- buy_single_index, buy_exec_index, compute_index, num, count, max_num_index = l2_data_manager.TradePointManager.get_buy_compute_start_data(
+ buy_single_index, buy_exec_index, compute_index, num, count, max_num_set = l2_data_manager.TradePointManager.get_buy_compute_start_data(
code)
- return buy_single_index, buy_exec_index, compute_index, num, count, max_num_index
+ return buy_single_index, buy_exec_index, compute_index, num, count, max_num_set
# 淇濆瓨涓嬪崟璧峰淇″彿
@classmethod
- def __save_order_begin_data(self, code, buy_single_index, buy_exec_index, compute_index, num, count, max_num_index):
+ def __save_order_begin_data(self, code, buy_single_index, buy_exec_index, compute_index, num, count, max_num_set):
TradePointManager.set_buy_compute_start_data(code, buy_single_index, buy_exec_index, compute_index, num, count,
- max_num_index)
+ max_num_set)
# 璁＄畻涓嬪崟璧峰淇″彿
# compute_data_count 鐢ㄤ簬璁＄畻鐨刲2鏁版嵁鏁伴噺
@@ -803,7 +797,7 @@
# 缁熻涔板叆鍑�涔伴噺锛屼笉璁＄畻鍦ㄤ拱鍏ヤ俊鍙蜂箣鍓嶇殑涔版挙鍗�
@classmethod
def __sum_buy_num_for_order_3(cls, code, compute_start_index, compute_end_index, origin_num, origin_count,
- threshold_money, buy_single_index, max_num_index):
+ threshold_money, buy_single_index, max_num_set):
def get_threshold_count():
count = threshold_count - sub_threshold_count
if count < 3:
@@ -856,9 +850,7 @@
max_space_time = pow(3, place_order_count + 1) - 1
# 鏈�澶т拱閲�
max_buy_num = 0
- max_buy_num_index = max_num_index
- if max_num_index > -1:
- max_buy_num = int(total_datas[max_num_index]["val"]["num"])
+ max_buy_num_set = set(max_num_set)
for i in range(compute_start_index, compute_end_index + 1):
data = total_datas[i]
_val = total_datas[i]["val"]
@@ -868,20 +860,18 @@
TradePointManager.delete_buy_point(code)
if i == compute_end_index:
# 鏁版嵁澶勭悊瀹屾瘯
- return None, buy_nums, buy_count, None, max_buy_num_index
+ return None, buy_nums, buy_count, None, max_buy_num_set
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, buy_count, ii, max_buy_num_index
+ return None, buy_nums, buy_count, ii, max_buy_num_set
# 娑ㄥ仠涔�
if L2DataUtil.is_limit_up_price_buy(_val):
if cls.__is_big_money(limit_up_price, _val):
sub_threshold_count += int(total_datas[i]["re"])
+ max_buy_num_set.add(i)
if round(int(_val["num"]) * float(_val["price"])) >= 5900:
- if int(_val["num"]) > max_buy_num:
- max_buy_num = int(_val["num"])
- max_buy_num_index = i
trigger_buy = True
# 鍙粺璁�59涓囦互涓婄殑閲戦
buy_nums += int(_val["num"]) * int(total_datas[i]["re"])
@@ -922,16 +912,15 @@
cls.buy_debug(code, "浣嶇疆-{}锛屾�绘墜鏁帮細{}锛岀洰鏍囨墜鏁帮細{}", i,
buy_nums, threshold_num)
# 鏈夋挙鍗曚俊鍙凤紝涓斿皬浜庨槇鍊�
- if buy_nums >= threshold_num and buy_count >= get_threshold_count() and trigger_buy and max_buy_num_index > -1 and cls.__is_big_money(
- limit_up_price, total_datas[max_buy_num_index]["val"]):
- return i, buy_nums, buy_count, None, max_buy_num_index
+ if buy_nums >= threshold_num and buy_count >= get_threshold_count() and trigger_buy and len(max_buy_num_set)>1:
+ return i, buy_nums, buy_count, None, max_buy_num_set
cls.buy_debug(code, "灏氭湭鑾峰彇鍒颁拱鍏ユ墽琛岀偣锛岃捣濮嬭绠椾綅缃細{} 缁熻绾拱鎵嬫暟锛歿} 鐩爣绾拱鎵嬫暟锛歿} 缁熻绾拱鍗曟暟锛歿} 鐩爣绾拱鍗曟暟锛歿} 澶у崟鏁伴噺锛歿}",
compute_start_index,
buy_nums,
threshold_num, buy_count, get_threshold_count(), sub_threshold_count)
- return None, buy_nums, buy_count, None, max_buy_num_index
+ return None, buy_nums, buy_count, None, max_buy_num_set
@classmethod
def test(cls):
@@ -2078,6 +2067,9 @@
total_data = local_today_datas[code]
latest_index = total_data[-1]["index"]
end_index = total_data[-1]["index"]
+ if end_index >= 434:
+ print("娴嬭瘯")
+
start_index = buy_exec_index
if tool.trade_time_sub(total_data[end_index]["val"]["time"], total_data[buy_exec_index]["val"]["time"]) < 3:
return
diff --git a/l2_data_util.py b/l2_data_util.py
index 6d8f514..25ad36b 100644
--- a/l2_data_util.py
+++ b/l2_data_util.py
@@ -178,7 +178,7 @@
# 淇濆瓨蹇収
# logger_l2_big_data.debug("code:{} d1:{} d2:{}", code, d1[i - 60: i + 30], d2[i - 60: i + 30])
break
- time_str = datetime.datetime.now().strftime("%H:%M:%S")
+ time_str = tool.get_now_time_str()
for time_ in same_time_nums:
# 鍙繚鐣欐渶杩�3s鍐呯殑澶ф暟鎹�
diff --git a/l2_trade_test.py b/l2_trade_test.py
index 4ec8f37..4d13d63 100644
--- a/l2_trade_test.py
+++ b/l2_trade_test.py
@@ -42,10 +42,17 @@
class VirtualTrade(unittest.TestCase):
- code = "002043"
+ code = "001236"
clear_trade_data(code)
l2_data_manager.load_l2_data(code)
total_datas = l2_data_manager.local_today_datas[code]
+ if total_datas[0]["index"] > 0:
+ # 鎷兼帴鏁版嵁
+ for i in range(0, total_datas[0]["index"]):
+ data = total_datas[0].copy()
+ data["index"] = i
+ total_datas.insert(i, data)
+
pos_list = log.get_l2_process_position(code)
if pos_list[0][0] > 0:
pos_list.insert(0, (0, pos_list[0][0] - 1))
@@ -66,8 +73,6 @@
l2_trade_factor.L2TradeFactorUtil.get_safe_buy_count = mock.Mock(return_value=21)
for indexs in pos_list:
L2TradeDataProcessor.random_key[code] = mock.Mock(return_value=random.randint(0, 100000))
- if indexs[0] >=898:
- print("")
# 璁剧疆灏佸崟棰濓紝鑾峰彇涔�1閲�
for i in range(0, 100):
time_ = total_datas[indexs[0]]["val"]["time"]
diff --git a/ocr_util.py b/ocr_util.py
new file mode 100644
index 0000000..234c839
--- /dev/null
+++ b/ocr_util.py
@@ -0,0 +1,28 @@
+import re
+import time
+
+import cv2
+from cnocr import CnOcr
+
+
+# 鍥惧儚璇嗗埆绫�
+class OcrUtil:
+ __ocr = CnOcr()
+
+ @classmethod
+ def ocr(cls, mat):
+ res = cls.__ocr.ocr(mat)
+ return res
+
+ # 杩斿洖(璇嗗埆鍐呭,浣嶇疆淇℃伅)
+ @classmethod
+ def ocr_with_key(cls, mat, key):
+ start = time.time()
+ res = cls.ocr(mat)
+ res_final = []
+ for r in res:
+ text = r["text"]
+ if re.match(key, text):
+ res_final.append((text, r["position"]))
+ print("璇嗗埆鏃堕棿",time.time() - start)
+ return res_final
\ No newline at end of file
diff --git a/server.py b/server.py
index 0ce1175..4a6fcd5 100644
--- a/server.py
+++ b/server.py
@@ -78,7 +78,7 @@
# print("- " * 30)
sk: socket.socket = self.request
while True:
- data = sk.recv(102400)
+ data = sk.recv(1024000)
if len(data) == 0:
# print("瀹㈡埛绔柇寮�杩炴帴")
break
@@ -191,7 +191,7 @@
# 淇濆瓨娑ㄥ仠鏃堕棿
gp_list = gpcode_manager.get_gp_list()
gp_code_set = set(gp_list)
- now_str = datetime.datetime.now().strftime("%H:%M:%S")
+ now_str = tool.get_now_time_str()
for d in dataList:
if d["time"] == "00:00:00" or tool.get_time_as_second(now_str) < tool.get_time_as_second(
d["time"]):
@@ -356,7 +356,7 @@
data = data_process.parse(_str)["data"]
client_id = data["client"]
print("L2鑷惎鍔ㄦ垚鍔�", client_id)
- now_str = datetime.datetime.now().strftime("%H:%M:%S")
+ now_str = tool.get_now_time_str()
ts = tool.get_time_as_second(now_str)
# 9鐐�25鍒�9鐐�28涔嬮棿鐨勮嚜鍚姩灏遍渶瑕佹壒閲忚缃唬鐮�
if tool.get_time_as_second("09:24:50") <= ts <= tool.get_time_as_second("09:28:00"):
@@ -389,6 +389,10 @@
return_str = json.dumps(return_json)
# print("蹇冭烦锛�", client_id)
+ elif type == 100:
+ # 鍥惧儚璇嗗埆
+ return_str = data_process.toJson({"code": 0, "data": {"datas": []}})
+ pass
sk.send(return_str.encode())
# print("----------handler end ----------")
diff --git a/ths_industry_util.py b/ths_industry_util.py
index 573efd3..04cdd4b 100644
--- a/ths_industry_util.py
+++ b/ths_industry_util.py
@@ -41,7 +41,7 @@
if code_industry_map is None:
raise Exception("鑾峰彇浠ｇ爜瀵瑰簲鐨勮涓氬嚭閿�")
- now_str = datetime.datetime.now().strftime("%H:%M:%S")
+ now_str = tool.get_now_time_str()
for data in limit_up_datas:
# 鏃堕棿姣旂幇鍦ㄦ棭鐨勬椂闂存墠绠楁暟
if data["time"] != "00:00:00" and tool.get_time_as_second(now_str) < tool.get_time_as_second(
diff --git a/trade_data_manager.py b/trade_data_manager.py
index 3707b57..9bf631e 100644
--- a/trade_data_manager.py
+++ b/trade_data_manager.py
@@ -229,7 +229,7 @@
# 9鐐瑰崐涔嬪墠鐨勬暟鎹笉澶勭悊
if int(time_str.replace(":", "")) < int("093000"):
return
- # now_str = datetime.datetime.now().strftime("%H:%M:%S")
+ # now_str = tool.get_now_time_str()
if rate >= 0:
down_start_time = self.__get_last_down_price_time(code)
if down_start_time is None:
@@ -262,12 +262,18 @@
return self.__get_current_price_codes_count()
# 鏄惁涓烘按涓嬫崬
- def is_under_water(self, code):
+ def is_under_water(self, code, now_time=None):
time_seconds = self.__get_down_price_time_as_seconds(code)
if time_seconds is None:
return False
else:
- return time_seconds >= constant.UNDER_WATER_PRICE_TIME_AS_SECONDS
+ if time_seconds >= constant.UNDER_WATER_PRICE_TIME_AS_SECONDS:
+ if now_time is None:
+ now_time = tool.get_now_time_str()
+ space = tool.trade_time_sub(now_time, "09:30:00")
+ if space > 0 and time_seconds / space >= 0.2:
+ return True
+ return False
# 褰撳墠浠ｇ爜鏄惁娑ㄥ仠
def current_is_limit_up(self, code):
diff --git a/trade_gui.py b/trade_gui.py
index 70255a1..77647b2 100644
--- a/trade_gui.py
+++ b/trade_gui.py
@@ -378,9 +378,9 @@
# 鎾ゅ崟蹇嵎閿甔
time.sleep(0.01)
- win32gui.PostMessage(win, win32con.WM_KEYDOWN, 0x00000058, 0x002D001);
- win32gui.PostMessage(win, win32con.WM_CHAR, 0x00000078, 0x002D001);
- win32gui.PostMessage(win, win32con.WM_KEYUP, 0x00000058, 0x002D001);
+ win32gui.PostMessage(win, win32con.WM_KEYDOWN, 0x00000058, 0x002D001)
+ win32gui.PostMessage(win, win32con.WM_CHAR, 0x00000078, 0x002D001)
+ win32gui.PostMessage(win, win32con.WM_KEYUP, 0x00000058, 0x002D001)
# win32gui.PostMessage(win, win32con.WM_KEYUP, 0x00000058, 0);
t = time.time()
print(t)
diff --git a/trade_manager.py b/trade_manager.py
index 942abd7..2793ed2 100644
--- a/trade_manager.py
+++ b/trade_manager.py
@@ -82,7 +82,7 @@
def save_trade_success_data(datas):
day = datetime.datetime.now().strftime("%Y%m%d")
redis = __redis_manager.getRedis()
- time_str = datetime.datetime.now().strftime("%H:%M:%S")
+ time_str = tool.get_now_time_str()
redis.setex("trade-success-latest-time", tool.get_expire(), time_str)
mysqldb = mysql_data.Mysqldb()
# 鍚堝苟鍚屼竴鍚堝悓缂栧彿
@@ -122,7 +122,7 @@
# 淇濆瓨浜ゆ槗濮旀墭鏁版嵁
def save_trade_delegate_data(datas):
day = datetime.datetime.now().strftime("%Y%m%d")
- time_str = datetime.datetime.now().strftime("%H:%M:%S")
+ time_str = tool.get_now_time_str()
mysqldb = mysql_data.Mysqldb()
for data in datas:
data["_id"] = "{}-{}-{}".format(day, data["code"], data["time"])
@@ -263,7 +263,7 @@
# 鍐嶆鎾ゅ崟锛岄槻姝㈡病鏈夋挙鎺�
@tool.async_call
def cancel_buy_again(code):
- time.sleep(0.1)
+ time.sleep(0.02)
for i in range(0, 5):
# 濡傛灉鏃�
trade_state = get_trade_state(code)
--
Gitblit v1.8.0