From b946684114d097e937b766f986d12c7eea8edce8 Mon Sep 17 00:00:00 2001
From: Administrator <admin@example.com>
Date: 星期日, 18 九月 2022 17:23:43 +0800
Subject: [PATCH] l2数据计算优化
---
l2_data_manager.py | 426 +++++++++++++++++++----------------------------------
1 files changed, 152 insertions(+), 274 deletions(-)
diff --git a/l2_data_manager.py b/l2_data_manager.py
index 3e81904..dd7890c 100644
--- a/l2_data_manager.py
+++ b/l2_data_manager.py
@@ -4,10 +4,13 @@
import time as t
from datetime import datetime
+import big_money_num_manager
import data_process
+import global_util
import l2_data_util
import gpcode_manager
+import l2_trade_factor
import redis_manager
import tool
@@ -54,68 +57,67 @@
@staticmethod
def delete_buy_point(code):
redis = TradePointManager.__get_redis()
- redis.delete("buy_compute_index-{}".format(code))
- redis.delete("buy_compute_num-{}".format(code))
-
- # 鍒犻櫎涔版挙鐐规暟鎹�
- @staticmethod
- def delete_buy_cancel_point(code):
- redis = TradePointManager.__get_redis()
- redis.delete("buy_cancel_compute_index-{}".format(code))
- redis.delete("buy_cancel_compute_num-{}".format(code))
+ redis.delete("buy_compute_index_info-{}".format(code))
# 鑾峰彇涔板叆鐐逛俊鎭�
+ # 杩斿洖鏁版嵁涓猴細涔板叆鐐� 绱绾拱棰� 宸茬粡璁＄畻鐨勬暟鎹储寮�
@staticmethod
def get_buy_compute_start_data(code):
redis = TradePointManager.__get_redis()
- index = redis.get("buy_compute_index-{}".format(code))
- total_num = redis.get("buy_compute_num-{}".format(code))
- if index is None:
- return None, 0
- else:
- return int(index), int(total_num)
+ _key = "buy_compute_index_info-{}".format(code)
+ _data_json = redis.get(_key)
+ if _data_json is None:
+ return None, 0, None
+ _data = json.loads(_data_json)
+ return _data[0], _data[1], _data[2]
# 璁剧疆涔板叆鐐圭殑鍊�
@staticmethod
- def set_buy_compute_start_data(code, num_add, index=None):
+ def set_buy_compute_start_data(code, nums, compute_index, buy_index):
redis = TradePointManager.__get_redis()
expire = tool.get_expire()
- if index is not None:
- redis.setex("buy_compute_index-{}".format(code), expire, index)
- key = "buy_compute_num-{}".format(code)
- if redis.get(key) is None:
- redis.setex(key, expire, num_add)
+ _key = "buy_compute_index_info-{}".format(code)
+ if buy_index is not None:
+ redis.setex(_key, expire, json.dumps((buy_index, nums, compute_index)))
else:
- redis.incrby(key, num_add)
+ _buy_index, _nums, _compute_index = TradePointManager.get_buy_compute_start_data(code)
+ redis.setex(_key, expire, json.dumps((_buy_index, nums, compute_index)))
# 鑾峰彇鎾や拱鍏ュ紑濮嬭绠楃殑淇℃伅
+ # 杩斿洖鏁版嵁鐨勫唴瀹逛负锛氭挙閿�鐐圭储寮� 鎾や拱绾拱棰� 璁＄畻鐨勬暟鎹储寮�
@staticmethod
def get_buy_cancel_compute_start_data(code):
redis = TradePointManager.__get_redis()
info = redis.get("buy_cancel_compute_info-{}".format(code))
if info is None:
- return None, None , None
+ return None, None, None
else:
- info=json.loads(info)
- return info[0],info[1],info[2]
+ info = json.loads(info)
+ return info[0], info[1], info[2]
# 璁剧疆涔版挙鐐逛俊鎭�
# buy_num 绾拱棰� computed_index璁＄畻鍒扮殑涓嬫爣 index鎾や拱淇″彿璧风偣
@classmethod
- def set_buy_cancel_compute_start_data(cls,code, buy_num,computed_index, index):
+ def set_buy_cancel_compute_start_data(cls, code, buy_num, computed_index, index):
redis = TradePointManager.__get_redis()
expire = tool.get_expire()
- redis.setex("buy_cancel_compute_info-{}".format(code), expire, json.dumps((index,buy_num,computed_index)))
+ redis.setex("buy_cancel_compute_info-{}".format(code), expire, json.dumps((index, buy_num, computed_index)))
# 澧炲姞鎾や拱鐨勭函涔伴
@classmethod
- def add_buy_nums_for_cancel(cls,code,num_add,computed_index):
- cancel_index,nums,c_index= cls.get_buy_cancel_compute_start_data(code)
+ def add_buy_nums_for_cancel(cls, code, num_add, computed_index):
+ cancel_index, nums, c_index = cls.get_buy_cancel_compute_start_data(code)
if cancel_index is None:
raise Exception("鏃犳挙涔颁俊鍙疯褰�")
- nums+=num_add
- cls.set_buy_cancel_compute_start_data(code,nums,computed_index)
+ nums += num_add
+ cls.set_buy_cancel_compute_start_data(code, nums, computed_index)
+
+ # 鍒犻櫎涔版挙鐐规暟鎹�
+ @staticmethod
+ def delete_buy_cancel_point(code):
+ redis = TradePointManager.__get_redis()
+ redis.delete("buy_cancel_compute_info-{}".format(code))
def load_l2_data(code, force=False):
@@ -360,6 +362,13 @@
return False
return True
+ @staticmethod
+ def is_index_end(code, index):
+ if index >= len(local_today_datas[code]) - 1:
+ return True
+ else:
+ return False
+
# L2浜ゆ槗鏁版嵁澶勭悊鍣�
class L2TradeDataProcessor:
@@ -396,6 +405,9 @@
total_datas[-1],
add_datas)
if len(add_datas) > 0:
+ # 璁＄畻澶у崟鏁伴噺
+ cls.__compute_big_money_data(code, add_datas)
+
latest_time = add_datas[len(add_datas) - 1]["val"]["time"]
# 鏃堕棿宸笉鑳藉お澶ф墠鑳藉鐞�
if L2DataUtil.is_same_time(now_time_str, latest_time):
@@ -403,45 +415,63 @@
state = trade_manager.get_trade_state(code)
if state == trade_manager.TRADE_STATE_BUY_DELEGATED or state == trade_manager.TRADE_STATE_BUY_PLACE_ORDER:
# 宸叉寕鍗�
- cls.process_order(code, add_datas)
+ cls.__process_order(code, len(total_datas) - len(add_datas) - 3)
else:
# 鏈寕鍗�
- cls.process_not_order(code, add_datas)
+ cls.__process_not_order(code, add_datas, capture_timestamp)
# 淇濆瓨鏁版嵁
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, add_datas):
+ # 璁＄畻澶у崟
+ num = 0
+ for data in add_datas:
+ 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, add_datas):
-
+ def __process_not_order(cls, code, add_datas, capture_time):
+ # 鑾峰彇闃堝��
+ threshold_money = cls.__get_threshmoney(code)
+ cls.__start_compute_buy(code, len(local_today_datas[code]) - len(add_datas), threshold_money, capture_time)
# 澶勭悊宸叉寕鍗�
@classmethod
- def process_order(cls, code, add_datas):
+ def __process_order(cls, code, start_index, capture_time):
+ if start_index < 0:
+ start_index = 0
# 鑾峰彇涔嬪墠鏄惁鏈夎褰曠殑鎾や拱淇″彿
- cancel_index, buy_num_for_cancel,computed_index= cls.has_order_cancel_begin_pos(code)
- buy_index, buy_num = cls.get_order_begin_pos(code)
+ cancel_index, buy_num_for_cancel, computed_index = cls.__has_order_cancel_begin_pos(code)
+ buy_index, buy_num = cls.__get_order_begin_pos(code)
if cancel_index is None:
# 鏃犳挙鍗曚俊鍙疯捣濮嬬偣璁板綍
- cancel_index = cls.compute_order_cancel_begin_single(code, len(add_datas) + 3, 3)
+ cancel_index = cls.__compute_order_cancel_begin_single(code, start_index, 3)
buy_num_for_cancel = 0
- computed_index=buy_index
+ computed_index = buy_index
if cancel_index is not None:
# 鑾峰彇闃堝�� 鏈変拱鎾や俊鍙凤紝缁熻鎾や拱绾拱棰�
- threshold_money=10000000
- cls.start_compute_cancel(code,cancel_index,computed_index,buy_num_for_cancel,threshold_money)
+ threshold_money = cls.__get_threshmoney(code)
+ cls.__start_compute_cancel(code, cancel_index, computed_index, buy_num_for_cancel, threshold_money,
+ capture_time)
else:
# 鏃犱拱鎾や俊鍙�,缁堟鎵ц
pass
- #寮�濮嬭绠楁挙鐨勪俊鍙�
+ # 寮�濮嬭绠楁挙鐨勪俊鍙�
@classmethod
- def start_compute_cancel(cls,code,cancel_index, compute_start_index,origin_num,threshold_money):
+ def __start_compute_cancel(cls, code, cancel_index, compute_start_index, origin_num, threshold_money, capture_time):
# sure_type 0-铏氭嫙鎸備拱浣� 1-鐪熷疄鎸備拱浣�
- computed_index , buy_num_for_cancel,sure_type = cls.sum_buy_num_for_cancel_order(code,compute_start_index,origin_num,threshold_money)
+ computed_index, buy_num_for_cancel, sure_type = cls.__sum_buy_num_for_cancel_order(code, compute_start_index,
+ origin_num, threshold_money)
total_datas = local_today_datas[code]
if computed_index is not None:
# 鍙戝嚭鎾や拱淇″彿锛岄渶瑕佹挙涔�
@@ -449,8 +479,8 @@
# 鏈夎櫄鎷熶笅鍗�
# 鍒犻櫎铏氭嫙涓嬪崟鏍囪
cls.unreal_buy_dict.pop(code)
- # TODO 鍒犻櫎涓嬪崟鏍囪浣嶇疆
- pass
+ # 鍒犻櫎涓嬪崟鏍囪浣嶇疆
+ TradePointManager.delete_buy_point(code)
else:
# 鏃犺櫄鎷熶笅鍗曪紝闇�瑕佹墽琛屾挙鍗�
logger_l2_trade.info(
@@ -463,86 +493,101 @@
except Exception as e:
pass
- if computed_index < len(local_today_datas[code])-1:
- # TODO鏁版嵁灏氭湭澶勭悊瀹�,閲嶆柊杩涘叆涓嬪崟璁＄畻娴佺▼
- cls.start_compute_buy(code,computed_index+1,0,threshold_money)
+ if computed_index < len(local_today_datas[code]) - 1:
+ # 鏁版嵁灏氭湭澶勭悊瀹�,閲嶆柊杩涘叆涓嬪崟璁＄畻娴佺▼
+ cls.__start_compute_buy(code, computed_index + 1, 0, threshold_money, capture_time)
pass
else:
- #鏃犻渶鎾や拱锛岃褰曟挙涔颁俊鍙�
- TradePointManager.set_buy_cancel_compute_start_data(code,buy_num_for_cancel,len(total_datas)-1,cancel_index)
+ # 鏃犻渶鎾や拱锛岃褰曟挙涔颁俊鍙�
+ TradePointManager.set_buy_cancel_compute_start_data(code, buy_num_for_cancel, len(total_datas) - 1,
+ cancel_index)
# 鍒ゆ柇鏄惁鏈夎櫄鎷熶笅鍗�
- unreal_buy_info=cls.unreal_buy_dict.get(code)
+ unreal_buy_info = cls.unreal_buy_dict.get(code)
if unreal_buy_info is not None:
# unreal_buy_info 鐨勫唴瀹规牸寮忎负锛�(瑙︽硶涔版搷浣滀笅鏍�,鎴浘鏃堕棿)
# 鐪熷疄涓嬪崟
- logger_l2_trade.info(
- "鎵ц涔板叆锛歿} ".format(code))
- try:
- trade_manager.start_buy(code, unreal_buy_info[1], total_datas[unreal_buy_info[0]],
- unreal_buy_info[0])
- TradePointManager.delete_buy_cancel_point(code)
- except Exception as e:
- pass
+ 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):
+ logger_l2_trade.info(
+ "鎵ц涔板叆锛歿} ".format(code))
+ try:
+ trade_manager.start_buy(code, capture_timestamp, last_data,
+ last_data_index)
+ TradePointManager.delete_buy_cancel_point(code)
+ except Exception as e:
+ pass
@classmethod
- def start_compute_buy(cls,code,compute_start_index,origin_num,threshold_money):
- total_datas=local_today_datas[code]
+ def __start_compute_buy(cls, code, compute_start_index, threshold_money, capture_time):
+ total_datas = local_today_datas[code]
# 鑾峰彇涔板叆淇″彿璁＄畻璧峰浣嶇疆
- index, num = cls.get_order_begin_pos(code)
+ index, num = cls.__get_order_begin_pos(code)
# 鏄惁涓烘柊鑾峰彇鍒扮殑浣嶇疆
new_get_pos = False
if index is None:
# 鏈変拱鍏ヤ俊鍙�
- has_single, index = cls.compute_order_begin_pos(code, len(total_datas) - compute_start_index , 3)
+ has_single, _index = cls.__compute_order_begin_pos(code, len(total_datas) - compute_start_index, 3)
+ index = _index
if has_single:
num = 0
new_get_pos = True
- # TODO 璁板綍涔板叆淇″彿浣嶇疆
+
if index is None:
# 鏈幏鍙栧埌涔板叆淇″彿锛岀粓姝㈢▼搴�
return None
-
# 涔板叆绾拱棰濈粺璁�
- # TODO 鑾峰彇闃堝��
- threshold_money=10000000
- compute_index,buy_nums = cls.sum_buy_num_for_order(code,compute_start_index,num,threshold_money)
+ compute_index, buy_nums = cls.sum_buy_num_for_order(code, compute_start_index, num, threshold_money)
if compute_index is not None:
- # 杈惧埌涓嬪崟鏉′欢
+ # 璁板綍涔板叆淇″彿浣嶇疆
+ cls.__save_order_begin_data(code, compute_index, buy_nums, index)
# 铏氭嫙涓嬪崟
- cls.unreal_buy_dict[code]=(compute_index,capture_time)
+ cls.unreal_buy_dict[code] = (compute_index, capture_time)
+ # 鍒犻櫎涔嬪墠鐨勬墍鏈夋挙鍗曚俊鍙�
+ TradePointManager.delete_buy_cancel_point(code)
+ # 鏁版嵁鏄惁澶勭悊瀹屾瘯
+ if L2DataUtil.is_index_end(code, compute_index):
+ # 鏁版嵁宸茬粡澶勭悊瀹屾瘯锛屼笅鍗�
+ cls.__buy(code, capture_time, total_datas[compute_index], compute_index)
+ else:
+ # 鏁版嵁灏氭湭澶勭悊瀹屾瘯锛岃繘琛屼笅涓�姝ュ鐞�
+ cls.__process_order(code, compute_index + 1, capture_time)
+
else:
- # TODO 鏈揪鍒颁笅鍗曟潯浠讹紝淇濆瓨绾拱棰濓紝璁剧疆绾拱棰�
-
-
+ # 鏈揪鍒颁笅鍗曟潯浠讹紝淇濆瓨绾拱棰濓紝璁剧疆绾拱棰�
+ # 璁板綍涔板叆淇″彿浣嶇疆
+ cls.__save_order_begin_data(code, len(total_datas) - 1, buy_nums, index)
pass
-
-
# 鑾峰彇涓嬪崟璧峰淇″彿
@classmethod
- def get_order_begin_pos(cls, code):
- index, num = TradePointManager.get_buy_compute_start_data(code)
+ def __get_order_begin_pos(cls, code):
+ index, num, compute_index = TradePointManager.get_buy_compute_start_data(code)
return index, num
+
+ @classmethod
+ def __save_order_begin_data(self, code, compute_index, num, buy_index=None):
+ TradePointManager.set_buy_compute_start_data(code, num, compute_index, buy_index)
# 鑾峰彇鎾ゅ崟璧峰浣嶇疆
@classmethod
- def has_order_cancel_begin_pos(cls):
+ def __has_order_cancel_begin_pos(cls, code):
# cancel_index:鎾ゅ崟淇″彿璧风偣
# buy_num_for_cancel锛氫粠鎸傚叆鐐硅绠楃殑绾拱棰�
# computed_index 璁＄畻鐨勬渶鍚庝綅缃�
- cancel_index, buy_num_for_cancel,computed_index = TradePointManager.get_buy_cancel_compute_start_data(code)
- return cancel_index, buy_num_for_cancel,computed_index
+ cancel_index, buy_num_for_cancel, computed_index = TradePointManager.get_buy_cancel_compute_start_data(code)
+ return cancel_index, buy_num_for_cancel, computed_index
# 璁＄畻涓嬪崟璧峰淇″彿
# compute_data_count 鐢ㄤ簬璁＄畻鐨刲2鏁版嵁鏁伴噺
- def compute_order_begin_pos(self, code, compute_data_count, continue_count):
+ def __compute_order_begin_pos(self, code, compute_data_count, continue_count):
# 鍊掓暟100鏉℃暟鎹煡璇�
datas = local_today_datas[code]
__len = len(datas)
@@ -617,17 +662,11 @@
# 鏄惁鏈夋挙閿�淇″彿
@classmethod
- def compute_order_cancel_begin_single(cls, code, compute_data_count, continue_count):
+ def __compute_order_cancel_begin_single(cls, code, start_index, continue_count):
datas = local_today_datas[code]
__len = len(datas)
- if __len < continue_count:
+ if len(datas) - start_index < continue_count:
return None
- start_index = 0
- if compute_data_count > __len:
- compute_data_count = __len
-
- if __len > compute_data_count:
- start_index = __len - compute_data_count
for i in range(start_index, __len - (continue_count - 1)):
_val = datas[i]["val"]
if L2DataUtil.get_time_as_second(_val["time"]) < second_930:
@@ -654,25 +693,20 @@
return i
return None
- # 淇濆瓨涓嬪崟浣嶇疆
- def save_order_pos(self):
- pass
-
# 鏄惁鍙互涓嬪崟
- def is_can_order(self):
+ def __is_can_order(self):
pass
# 铏氭嫙涓嬪崟
- def unreal_order(self):
+ def __unreal_order(self):
pass
- # 璁剧疆铏氭嫙鎸備拱浣�
- def set_unreal_sure_order_pos(self):
- pass
+ def __get_threshmoney(cls, code):
+ l2_trade_factor.L2TradeFactorUtil.compute_m_value(code)
# 鑾峰彇棰勪及鎸備拱浣�
@classmethod
- def get_sure_order_pos(cls, code):
+ def __get_sure_order_pos(cls, code):
index, data = TradeBuyDataManager.get_buy_sure_position(code)
if index is None:
return 0, len(local_today_datas[code]) - 1, local_today_datas[code][-1]
@@ -681,7 +715,7 @@
# 缁熻涔板叆鍑�涔伴噺
@classmethod
- def sum_buy_num_for_order(cls, code, compute_start_index, origin_num, threshold_money):
+ 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)
@@ -703,13 +737,18 @@
# 鍚屼竴鏃堕棿涔板叆鐨勬鐜囪绠�
@classmethod
- def get_same_time_property(cls, code):
- # TODO 涓庢澘鍧楃儹搴︽湁鍏�
+ 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):
+ def __sum_buy_num_for_cancel_order(cls, code, start_index, origin_num, threshold_money):
buy_nums = origin_num
total_datas = local_today_datas[code]
limit_up_price = gpcode_manager.get_limit_up_price(code)
@@ -717,8 +756,8 @@
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)
+ 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
for i in range(start_index, len(total_datas)):
@@ -749,169 +788,8 @@
property_buy_num = round(property_buy_num_count * same_time_property)
if buy_nums + property_buy_num <= threshold_num:
- return i, buy_nums + property_buy_num,sure_type
- return None, buy_nums + round(property_buy_num_count * same_time_property),sure_type
-
-
-def process_data(code, datas, capture_timestamp):
- now_time_str = datetime.now().strftime("%H:%M:%S")
- __start_time = round(t.time() * 1000)
- try:
- if len(datas) > 0:
- # 鍒ゆ柇浠锋牸鍖洪棿鏄惁姝ｇ‘
- if not data_process.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 = correct_data(code, datas)
- add_datas = get_add_data(code, datas)
- 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:
- latest_time = add_datas[len(add_datas) - 1]["val"]["time"]
- # 鏃堕棿宸笉鑳藉お澶ф墠鑳藉鐞�
- if __is_same_time(now_time_str, latest_time):
- # logger.info("鍙婃椂鐨勬暟鎹紝鏂板鏁版嵁鏁伴噺{}".format(len(add_datas)))
-
- # 鏄惁宸茬粡鏈変拱鍏ュ紑濮嬭绠楃偣
- c_index, c_num = TradePointManager.get_buy_compute_start_data(code)
- if c_index is None:
- # 鍒ゆ柇鏄惁鍑虹幇绂佹浜ゆ槗淇″彿
- forbidden = __is_have_forbidden_feature(code, len(add_datas) + 6, 6)
- if forbidden:
- trade_manager.forbidden_trade(code)
-
- # 娌℃湁璁＄畻寮�濮嬬偣
- c_index = __get_limit_up_buy_start(code, len(add_datas) + 3, 3)
- if c_index is not None:
-
- logger_l2_trade.info("鎵惧埌涔扮偣锛歿} - {}".format(code, json.dumps(total_datas[c_index])))
-
- # 瑙﹀彂鏁版嵁鍒嗘瀽 锛岃幏鍙栬繛缁定鍋滄爣璁版暟鎹�
- buy_nums = 0
- # 鑾峰彇娑ㄥ仠浠�
- limit_up_price = gpcode_manager.get_limit_up_price(code)
- last_data_index = -1
- for i in range(c_index, len(total_datas)):
- _val = total_datas[i]["val"]
- # 鏈夎繛缁�4涓定鍋滀拱灏辨爣璁拌绠楄捣濮嬬偣
- if int(_val["limitPrice"]) == 1 and int(_val["operateType"]) == 0:
- # 娑ㄥ仠涔�
- buy_nums += int(_val["num"]) * int(total_datas[i]["re"])
- elif int(_val["limitPrice"]) == 1 and int(_val["operateType"]) == 1:
- # 娑ㄥ仠涔版挙
- buy_nums -= int(_val["num"]) * int(total_datas[i]["re"])
- if buy_nums * limit_up_price * 100 > 1000 * 10000:
- last_data_index = i
- break
-
- TradePointManager.set_buy_compute_start_data(code, buy_nums, c_index)
-
- if limit_up_price is not None:
- if last_data_index > -1:
- # 澶т簬1000w灏变拱
- logger_l2_trade.info(
- "鎵ц涔板叆锛歿} - 璁＄畻缁撴潫鐐癸細 {}".format(code, json.dumps(total_datas[-1])))
- try:
- trade_manager.start_buy(code, capture_timestamp, total_datas[last_data_index],
- last_data_index)
- TradePointManager.delete_buy_cancel_point(code)
- except Exception as e:
- pass
- else:
- # 鏈夎绠楀紑濮嬬偣,璁＄畻鏂板鐨勬暟鎹�
- buy_nums = c_num
- last_data = None
- last_data_index = len(total_datas) - len(add_datas) - 1
- # 鑾峰彇娑ㄥ仠浠�
- limit_up_price = gpcode_manager.get_limit_up_price(code)
- for data in add_datas:
- last_data_index += 1
- _val = data["val"]
- if int(_val["limitPrice"]) == 1 and int(_val["operateType"]) == 0:
- # 娑ㄥ仠涔�
- buy_nums += int(_val["num"]) * int(data["re"])
- elif int(_val["limitPrice"]) == 1 and int(_val["operateType"]) == 1:
- # 娑ㄥ仠涔版挙
- buy_nums -= int(_val["num"]) * int(data["re"])
- if buy_nums * limit_up_price * 100 > 1000 * 10000:
- last_data = data
- break
-
- TradePointManager.set_buy_compute_start_data(code, buy_nums)
- if limit_up_price is not None:
- if last_data is not None:
- # 澶т簬1000w灏变拱
- logger_l2_trade.info("鎵ц涔板叆锛歿} - 璁＄畻缁撴潫鐐癸細 {}".format(code, json.dumps(add_datas[-1])))
- try:
- trade_manager.start_buy(code, capture_timestamp, last_data, last_data_index)
- TradePointManager.delete_buy_cancel_point(code)
- except Exception as e:
- pass
-
- if c_index is not None:
- # 鏄惁澶勪簬濮旀墭寰呮垚浜�
- state = trade_manager.get_trade_state(code)
- if state == trade_manager.TRADE_STATE_BUY_DELEGATED or state == trade_manager.TRADE_STATE_BUY_PLACE_ORDER:
- # 宸茬粡濮旀墭锛屾娴嬪彇娑堟帴鍙�
- cancel_index, cancel_num = TradePointManager.get_buy_cancel_compute_start_data(code)
- if cancel_index is None:
- # 涔嬪墠灏氭湭鐩戞祴鍒颁拱鎾よ捣鐐�
- cancel_index = __get_limit_up_buy_cancel_start(code, len(add_datas) + 3, 3)
- if cancel_index is not None:
- total_datas = local_today_datas[code]
- # print("鎵惧埌涔版挙鐐�", cancel_index, total_datas[cancel_index])
- logger_l2_trade.info(
- "鎵惧埌涔版挙鐐癸細{} - {}".format(code, json.dumps(total_datas[cancel_index])))
-
- # 瑙﹀彂鏁版嵁鍒嗘瀽 锛岃幏鍙栬繛缁定鍋滄爣璁版暟鎹�
- nums = 0
- for i in range(c_index, len(total_datas)):
- _val = total_datas[i]["val"]
- if int(_val["limitPrice"]) == 1 and int(_val["operateType"]) == 1:
- # 娑ㄥ仠涔版挙
- nums += int(_val["num"]) * int(total_datas[i]["re"])
-
- TradePointManager.set_buy_cancel_compute_start_data(code, nums, cancel_index)
- else:
- # 涔嬪墠鐩戞祴鍒颁簡涔版挙閿�璧风偣
- cancel_nums_add = 0
- for data in add_datas:
- _val = data["val"]
- if int(_val["limitPrice"]) == 1 and int(_val["operateType"]) == 1:
- # 娑ㄥ仠涔版挙
- cancel_nums_add += int(_val["num"]) * int(data["re"])
- TradePointManager.set_buy_cancel_compute_start_data(code, cancel_nums_add)
- latest_num = cancel_num + cancel_nums_add
- # 鑾峰彇娑ㄥ仠浠�
- limit_up_price = gpcode_manager.get_limit_up_price(code)
- if limit_up_price is not None:
- if latest_num * limit_up_price * 100 > 1000 * 10000:
- # 澶т簬1000w灏变拱
- # print("鎵ц鎾ら攢")
- logger_l2_trade.info(
- "鎵ц鎾ら攢锛歿} - {}".format(code, json.dumps(add_datas[-1])))
- try:
- trade_manager.start_cancel_buy(code)
- # 鍙栨秷涔板叆鏍囪瘑
- TradePointManager.delete_buy_point(code)
- TradePointManager.delete_buy_cancel_point(code)
- except Exception as e:
- pass
-
- pass
- # 淇濆瓨鏁版嵁
- save_l2_data(code, datas, add_datas)
- finally:
- pass
+ return i, buy_nums + property_buy_num, sure_type
+ return None, buy_nums + round(property_buy_num_count * same_time_property), sure_type
def __get_time_second(time_str):
@@ -1168,8 +1046,8 @@
for line in f.readlines(): # 渚濇璇诲彇姣忚
line = line.strip()
data = json.loads(line)
- result = __format_l2_data(data, code, 10.00)
- add_datas = get_add_data(code, result)
+ result = L2DataUtil.format_l2_data(data, code, 10.00)
+ add_datas = L2DataUtil.get_add_data(code, result)
print("澧炲姞鐨勬暟閲忥細", len(add_datas))
if len(add_datas) > 0:
# 鎷兼帴鏁版嵁
--
Gitblit v1.8.0