From 0e68e24f54db11d340785b17570fff2bc5fc7ac6 Mon Sep 17 00:00:00 2001
From: Administrator <admin@example.com>
Date: 星期一, 24 七月 2023 13:05:16 +0800
Subject: [PATCH] bug修复
---
l2/l2_data_manager_new.py | 923 +++++++++++++++++++++++++++++++++------------------------
1 files changed, 538 insertions(+), 385 deletions(-)
diff --git a/l2/l2_data_manager_new.py b/l2/l2_data_manager_new.py
index 6df20ba..30015b9 100644
--- a/l2/l2_data_manager_new.py
+++ b/l2/l2_data_manager_new.py
@@ -1,33 +1,34 @@
import logging
-import random
import time as t
-import big_money_num_manager
-import code_data_util
+from code_attribute import big_money_num_manager, code_volumn_manager, code_data_util, industry_codes_sort, \
+ limit_up_time_manager, global_data_loader, gpcode_manager
import constant
-import global_util
-import gpcode_manager
-import industry_codes_sort
+from l2.huaxin import l2_huaxin_util, huaxin_delegate_postion_manager
+from third_data import kpl_data_manager, block_info
+from utils import global_util, ths_industry_util, tool
import l2_data_util
-import l2_trade_test
-import limit_up_time_manager
from db import redis_manager
-import ths_industry_util
-import tool
-from trade import trade_data_manager, trade_manager, trade_queue_manager, l2_trade_factor, l2_trade_util, \
- trade_result_manager
-from l2 import safe_count_manager, l2_data_manager, l2_data_log
+from third_data.code_plate_key_manager import CodePlateKeyBuyManager
+from trade import trade_manager, trade_queue_manager, l2_trade_factor, l2_trade_util, \
+ trade_result_manager, first_code_score_manager, current_price_process_manager
+from l2 import safe_count_manager, l2_data_manager, l2_data_log, l2_log, l2_data_source_util, code_price_manager, \
+ transaction_progress
from l2.cancel_buy_strategy import SecondCancelBigNumComputer, HourCancelBigNumComputer, L2LimitUpMoneyStatisticUtil, \
- L2LimitUpSellStatisticUtil
+ L2LimitUpSellStatisticUtil, DCancelBigNumComputer, LCancelBigNumComputer
from l2.l2_data_manager import L2DataException, TradePointManager
-from l2.l2_data_util import local_today_datas, L2DataUtil, load_l2_data, local_today_num_operate_map, local_latest_datas
+from l2.l2_data_util import local_today_datas, L2DataUtil, local_today_num_operate_map, local_today_buyno_map, \
+ local_latest_datas
import l2.l2_data_util
-from log import logger_l2_trade, logger_l2_trade_cancel, logger_l2_trade_buy, logger_l2_process, logger_l2_error
+from log_module.log import logger_l2_trade_buy, logger_l2_process, \
+ logger_place_order_score, logger_l2_error
# TODO l2鏁版嵁绠＄悊
from trade.trade_data_manager import CodeActualPriceProcessor
import dask
+
+from trade.trade_manager import TradeTargetCodeModeManager
class L2DataManager:
@@ -121,8 +122,9 @@
# 濡傛灉鏄定鍋滀拱鎾や俊鍙烽渶瑕佺湅鏁版嵁浣嶇疆鏄惁姣斿紑濮嬪鐞嗘椂闂存棭
if L2DataUtil.is_limit_up_price_buy_cancel(data["val"]):
# 鑾峰彇涔板叆淇″彿
- buy_index, buy_data = l2_data_util.get_buy_data_with_cancel_data(total_datas[i],
- local_today_num_operate_map.get(code))
+ buy_index = l2_data_source_util.L2DataSourceUtils.get_buy_index_with_cancel_data(code, total_datas[i],
+ local_today_num_operate_map.get(
+ code))
if buy_index is not None and buy_index < begin_pos:
continue
@@ -152,34 +154,30 @@
class L2TradeDataProcessor:
unreal_buy_dict = {}
- random_key = {}
+ volume_rate_info = {}
l2BigNumForMProcessor = L2BigNumForMProcessor()
__codeActualPriceProcessor = CodeActualPriceProcessor()
- buy1PriceManager = trade_queue_manager.Buy1PriceManager()
__ths_l2_trade_queue_manager = trade_queue_manager.thsl2tradequeuemanager()
__thsBuy1VolumnManager = trade_queue_manager.THSBuy1VolumnManager()
__buyL2SafeCountManager = safe_count_manager.BuyL2SafeCountManager()
+ __l2PlaceOrderParamsManagerDict = {}
+ __last_buy_single_dict = {}
+ __TradeBuyQueue = transaction_progress.TradeBuyQueue()
+ # 鑾峰彇浠ｇ爜璇勫垎
@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))
+ def get_code_scores(cls):
+ score_dict = {}
+ for code in cls.__l2PlaceOrderParamsManagerDict:
+ score = cls.__l2PlaceOrderParamsManagerDict[code].score
+ score_dict[code] = score
+ return score_dict
@classmethod
# 鏁版嵁澶勭悊鍏ュ彛
# datas: 鏈鎴浘鏁版嵁
# capture_timestamp:鎴浘鏃堕棿鎴�
- def process(cls, code, datas, capture_timestamp, do_id):
- cls.random_key[code] = do_id
+ def process(cls, code, datas, capture_timestamp):
__start_time = round(t.time() * 1000)
try:
if len(datas) > 0:
@@ -187,10 +185,16 @@
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"]))
- # 鍔犺浇鍘嗗彶鏁版嵁
- l2.l2_data_util.load_l2_data(code)
+ # 鍔犺浇鍘嗗彶鏁版嵁,杩斿洖鏁版嵁鏄惁姝ｅ父
+ is_normal = l2.l2_data_util.load_l2_data(code)
+ if not is_normal:
+ print("鍘嗗彶鏁版嵁寮傚父:", code)
+ # 鏁版嵁涓嶆甯搁渶瑕佺姝氦鏄�
+ l2_trade_util.forbidden_trade(code)
# 绾犳鏁版嵁
- datas = l2.l2_data_util.L2DataUtil.correct_data(code, local_latest_datas.get(code), datas)
+ if constant.L2_SOURCE_TYPE == constant.L2_SOURCE_TYPE_THS:
+ # 鍚岃姳椤洪渶瑕佺籂姝ｆ暟鎹紝鍏朵粬娓犻亾涓嶉渶瑕�
+ datas = l2.l2_data_util.L2DataUtil.correct_data(code, local_latest_datas.get(code), datas)
_start_index = 0
if local_today_datas.get(code) is not None and len(
local_today_datas[code]) > 0:
@@ -203,13 +207,50 @@
finally:
# 淇濆瓨鏁版嵁
__start_time = round(t.time() * 1000)
- l2.l2_data_util.save_l2_data(code, datas, add_datas, cls.random_key[code])
- __start_time = l2_data_log.l2_time(code, cls.random_key[code],
+ l2.l2_data_util.save_l2_data(code, datas, add_datas)
+ __start_time = l2_data_log.l2_time(code,
round(t.time() * 1000) - __start_time,
"淇濆瓨鏁版嵁鏃堕棿锛坽}锛�".format(len(add_datas)))
finally:
if code in cls.unreal_buy_dict:
cls.unreal_buy_dict.pop(code)
+
+ # 澶勭悊鍗庨懌L2鏁版嵁
+ @classmethod
+ def process_huaxin(cls, code, datas):
+ print("process_huaxin", code, len(datas))
+ origin_start_time = round(t.time() * 1000)
+ try:
+ # 鍔犺浇鍘嗗彶鐨凩2鏁版嵁
+ is_normal = l2.l2_data_util.load_l2_data(code, load_latest=False)
+ if not is_normal:
+ print("鍘嗗彶鏁版嵁寮傚父:", code)
+ # 鏁版嵁涓嶆甯搁渶瑕佺姝氦鏄�
+ l2_trade_util.forbidden_trade(code)
+ # 杞崲鏁版嵁鏍煎紡
+ _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
+ datas = l2_huaxin_util.get_format_l2_datas(code, datas,
+ gpcode_manager.get_limit_up_price(code), _start_index)
+ # 鑾峰彇涓嬪崟浣嶇疆
+ place_order_index = huaxin_delegate_postion_manager.get_l2_place_order_position(code, datas)
+ if place_order_index:
+ logger_l2_process.info("code:{} 鑾峰彇鍒颁笅鍗曠湡瀹炰綅缃細{}", code, place_order_index)
+ DCancelBigNumComputer.set_real_order_index(code, place_order_index)
+
+ __start_time = round(t.time() * 1000)
+ cls.process_add_datas(code, datas, 0, __start_time)
+ except Exception as e:
+ print("huaxin L2鏁版嵁澶勭悊寮傚父", code, str(e))
+ logging.exception(e)
+ logger_l2_error.exception(e)
+ finally:
+ l2_data_log.l2_time(code, round(t.time() * 1000) - origin_start_time,
+ "l2鏁版嵁澶勭悊鎬昏�楁椂",
+ True)
+ l2.l2_data_util.save_l2_data(code, None, datas)
@classmethod
def process_add_datas(cls, code, add_datas, capture_timestamp, __start_time):
@@ -218,7 +259,8 @@
print(id(local_today_datas))
# 鎷兼帴鏁版嵁
local_today_datas[code].extend(add_datas)
- l2.l2_data_util.load_num_operate_map(l2.l2_data_util.local_today_num_operate_map, code, add_datas)
+ l2.l2_data_util.load_num_operate_map(local_today_num_operate_map, code, add_datas)
+ l2.l2_data_util.load_buy_no_map(local_today_buyno_map, code, add_datas)
# 绗�1鏉℃暟鎹槸鍚︿负09:30:00
if add_datas[0]["val"]["time"] == "09:30:00":
@@ -231,52 +273,72 @@
limit_up_time_manager.save_limit_up_time(code, "09:30:00")
total_datas = local_today_datas[code]
- __start_time = l2_data_log.l2_time(code, cls.random_key[code], round(t.time() * 1000) - __start_time,
+ __start_time = l2_data_log.l2_time(code, round(t.time() * 1000) - __start_time,
"l2鏁版嵁棰勫鐞嗘椂闂�")
if len(add_datas) > 0:
+ # 鏄惁涓洪鏉夸唬鐮�
+ is_first_code = gpcode_manager.FirstCodeManager.is_in_first_record(code)
+ # 璁＄畻閲�
+ volume_rate = code_volumn_manager.get_volume_rate(code)
+ volume_rate_index = code_volumn_manager.get_volume_rate_index(volume_rate)
+ # 璁＄畻鍒嗗��
+ limit_up_time = limit_up_time_manager.get_limit_up_time(code)
+ if limit_up_time is None:
+ limit_up_time = tool.get_now_time_str()
+ score = first_code_score_manager.get_score(code, volume_rate, limit_up_time, True)
+ cls.__l2PlaceOrderParamsManagerDict[code] = l2_trade_factor.L2PlaceOrderParamsManager(code, is_first_code,
+ volume_rate,
+ volume_rate_index,
+ score,
+ total_datas[-1][
+ 'val']['time'])
+ cls.volume_rate_info[code] = (volume_rate, volume_rate_index)
+
latest_time = add_datas[len(add_datas) - 1]["val"]["time"]
+
+ __start_time = l2_data_log.l2_time(code, round(t.time() * 1000) - __start_time,
+ "l2鏁版嵁鍑嗗鏃堕棿")
# 鏃堕棿宸笉鑳藉お澶ф墠鑳藉鐞�
- if l2.l2_data_util.L2DataUtil.is_same_time(now_time_str,
- latest_time) and not l2_trade_util.is_in_forbidden_trade_codes(
- code):
+ if not l2_trade_util.is_in_forbidden_trade_codes(code):
# 鍒ゆ柇鏄惁宸茬粡鎸傚崟
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 or state == trade_manager.TRADE_STATE_BUY_SUCCESS:
# 宸叉寕鍗�
- cls.__process_order(code, start_index, end_index, capture_timestamp)
+ cls.__process_order(code, start_index, end_index, capture_timestamp, is_first_code)
else:
- # 鏈寕鍗�
- cls.__process_not_order(code, start_index, end_index, capture_timestamp)
+ # 鏈寕鍗�,鏃堕棿鐩稿樊涓嶅ぇ鎵嶈兘鎸傚崟
+ if l2.l2_data_util.L2DataUtil.is_same_time(now_time_str, latest_time):
+ cls.__process_not_order(code, start_index, end_index, capture_timestamp, is_first_code)
logger_l2_process.info("code:{} 澶勭悊鏁版嵁鑼冨洿: {}-{} 澶勭悊鏃堕棿:{} 鎴浘鏃堕棿鎴筹細{}", code, add_datas[0]["index"],
add_datas[-1]["index"], round(t.time() * 1000) - __start_time,
capture_timestamp)
- __start_time = l2_data_log.l2_time(code, cls.random_key[code], round(t.time() * 1000) - __start_time,
+ __start_time = l2_data_log.l2_time(code, round(t.time() * 1000) - __start_time,
"l2鏁版嵁澶勭悊鏃堕棿")
# 澶勭悊鏈寕鍗�
@classmethod
- def __process_not_order(cls, code, start_index, end_index, capture_time):
+ def __process_not_order(cls, code, start_index, end_index, capture_time, is_first_code):
__start_time = round(t.time() * 1000)
# 鑾峰彇闃堝��
threshold_money, msg = cls.__get_threshmoney(code)
if round(t.time() * 1000) - __start_time > 10:
- __start_time = l2_data_log.l2_time(code, cls.random_key.get(code), round(t.time() * 1000) - __start_time,
+ __start_time = l2_data_log.l2_time(code, round(t.time() * 1000) - __start_time,
"鑾峰彇m鍊兼暟鎹�楁椂")
- cls.__start_compute_buy(code, start_index, end_index, threshold_money, capture_time)
+ cls.__start_compute_buy(code, start_index, end_index, threshold_money, capture_time, is_first_code)
# 娴嬭瘯涓撶敤
@classmethod
- def process_order(cls, code, start_index, end_index, capture_time, new_add=True):
- cls.__process_order(code, start_index, end_index, capture_time, new_add)
+ def process_order(cls, code, start_index, end_index, capture_time, is_first_code, new_add=True):
+ cls.__process_order(code, start_index, end_index, capture_time, is_first_code, new_add)
# 澶勭悊宸叉寕鍗�
@classmethod
- def __process_order(cls, code, start_index, end_index, capture_time, new_add=True):
+ def __process_order(cls, code, start_index, end_index, capture_time, is_first_code, new_add=True):
# 璁＄畻瀹夊叏绗旀暟
@dask.delayed
def compute_safe_count():
@@ -285,7 +347,7 @@
cls.__buyL2SafeCountManager.compute_left_rate(code, start_index, end_index, total_data,
local_today_num_operate_map.get(code))
- l2_data_log.l2_time(code, cls.random_key[code], round(t.time() * 1000) - _start_time,
+ l2_data_log.l2_time(code, round(t.time() * 1000) - _start_time,
"宸蹭笅鍗�-鑾峰彇涔板叆淇℃伅鑰楁椂")
return None, ""
@@ -296,7 +358,7 @@
# 璁＄畻m鍊煎ぇ鍗�
cls.l2BigNumForMProcessor.process(code, max(buy_single_index, start_index), end_index,
gpcode_manager.get_limit_up_price(code))
- l2_data_log.l2_time(code, cls.random_key[code], round(t.time() * 1000) - _start_time,
+ l2_data_log.l2_time(code, round(t.time() * 1000) - _start_time,
"宸蹭笅鍗�-m鍊煎ぇ鍗曡绠�")
return None, ""
@@ -305,13 +367,15 @@
def buy_1_cancel():
_start_time = round(t.time() * 1000)
# 鎾ゅ崟璁＄畻,鍙湅涔�1
- cancel_data, cancel_msg = L2LimitUpMoneyStatisticUtil.process_data(cls.random_key[code], code, start_index,
+ cancel_data, cancel_msg = L2LimitUpMoneyStatisticUtil.process_data(code, start_index,
end_index,
buy_single_index, buy_exec_index)
- l2_data_log.l2_time(code, cls.random_key[code], round(t.time() * 1000) - _start_time,
+ l2_data_log.l2_time(code, round(t.time() * 1000) - _start_time,
"宸蹭笅鍗�-涔�1缁熻鑰楁椂")
- return cancel_data, cancel_msg
+ # 涔�1涓嶄細瑙﹀彂鎾ゅ崟
+ return None, ""
+ # return cancel_data, cancel_msg
# S鎾�
@dask.delayed
@@ -322,13 +386,16 @@
b_need_cancel, b_cancel_data = SecondCancelBigNumComputer.need_cancel(code, buy_single_index,
buy_exec_index, start_index,
end_index, total_data,
- cls.random_key[code])
+ code_volumn_manager.get_volume_rate_index(
+ buy_volume_rate),
+ cls.volume_rate_info[code][1],
+ is_first_code)
if b_need_cancel:
return b_cancel_data, "S澶у崟鎾ら攢姣斾緥瑙﹀彂闃堝��"
except Exception as e:
logging.exception(e)
finally:
- l2_data_log.l2_time(code, cls.random_key[code], round(t.time() * 1000) - _start_time,
+ l2_data_log.l2_time(code, round(t.time() * 1000) - _start_time,
"宸蹭笅鍗�-s绾уぇ鍗曚及绠�")
return None, ""
@@ -337,15 +404,39 @@
def h_cancel():
_start_time = round(t.time() * 1000)
try:
- b_need_cancel, b_cancel_data = HourCancelBigNumComputer.need_cancel(code, buy_exec_index, start_index,
+ b_need_cancel, b_cancel_data = HourCancelBigNumComputer.need_cancel(code, buy_single_index,
+ buy_exec_index, start_index,
end_index, total_data,
- cls.random_key[code])
- if b_need_cancel and not cancel_data:
+ local_today_num_operate_map.get(
+ code),
+ code_volumn_manager.get_volume_rate_index(
+ buy_volume_rate),
+ cls.volume_rate_info[code][1],
+ is_first_code)
+ if b_need_cancel and b_cancel_data:
return b_cancel_data, "H鎾ら攢姣斾緥瑙﹀彂闃堝��"
except Exception as e:
logging.exception(e)
finally:
- l2_data_log.l2_time(code, cls.random_key[code], round(t.time() * 1000) - _start_time, "宸蹭笅鍗�-H鎾ゅぇ鍗曡绠�")
+ l2_data_log.l2_time(code, round(t.time() * 1000) - _start_time, "宸蹭笅鍗�-H鎾ゅぇ鍗曡绠�")
+ return None, ""
+
+ # L鎾�
+ @dask.delayed
+ def l_cancel():
+ _start_time = round(t.time() * 1000)
+ try:
+ b_need_cancel, b_cancel_data = LCancelBigNumComputer.need_cancel(code,
+ buy_exec_index, start_index,
+ end_index, total_data,
+ local_today_num_operate_map.get(
+ code), is_first_code)
+ if b_need_cancel and b_cancel_data:
+ return b_cancel_data, "L鎾ら攢姣斾緥瑙﹀彂闃堝��"
+ except Exception as e:
+ logging.exception(e)
+ finally:
+ l2_data_log.l2_time(code, round(t.time() * 1000) - _start_time, "宸蹭笅鍗�-L鎾ゅぇ鍗曡绠�")
return None, ""
# 鏉夸笂鍗栨挙
@@ -354,37 +445,29 @@
_start_time = round(t.time() * 1000)
# 缁熻鏉夸笂鍗�
try:
- cancel_data, cancel_msg = L2LimitUpSellStatisticUtil.process(cls.random_key[code], code, start_index,
+ cancel_data, cancel_msg = L2LimitUpSellStatisticUtil.process(code, start_index,
end_index,
buy_exec_index)
return cancel_data, cancel_msg
except Exception as e:
logging.exception(e)
finally:
- l2_data_log.l2_time(code, cls.random_key[code], round(t.time() * 1000) - _start_time, "宸蹭笅鍗�-鏉夸笂鍗栬�楁椂")
+ l2_data_log.l2_time(code, round(t.time() * 1000) - _start_time, "宸蹭笅鍗�-鏉夸笂鍗栬�楁椂")
return None, ""
# 鏄惁闇�瑕佹挙閿�
@dask.delayed
def is_need_cancel(*args):
- f_cancel_data, f_cancel_msg = None, ""
try:
for i in range(0, len(args)):
_cancel_data, _cancel_msg = args[i]
if _cancel_data:
- if not f_cancel_data:
- f_cancel_data, f_cancel_msg = _cancel_data, _cancel_msg
- else:
- if _cancel_data["index"] < f_cancel_data["index"]:
- # 鍙栬緝鏃╃殑鎾ら攢鏁版嵁
- f_cancel_data, f_cancel_msg = _cancel_data, _cancel_msg
-
-
+ return _cancel_data, _cancel_msg
except Exception as e:
logging.exception(e)
finally:
pass
- return f_cancel_data, f_cancel_msg
+ return None, ""
if start_index < 0:
start_index = 0
@@ -392,76 +475,105 @@
if end_index < start_index:
return
total_data = local_today_datas.get(code)
- _start_time = round(t.time() * 1000)
+ _start_time = tool.get_now_timestamp()
# 鑾峰彇涔板叆淇″彿璧峰鐐�
- buy_single_index, buy_exec_index, buy_compute_index, num, count, max_num_set = cls.__get_order_begin_pos(code)
+ buy_single_index, buy_exec_index, buy_compute_index, num, count, max_num_set, buy_volume_rate = cls.__get_order_begin_pos(
+ code)
f1 = compute_safe_count()
f2 = compute_m_big_num()
- f3 = buy_1_cancel()
- f4 = s_cancel()
- f5 = h_cancel()
+ f3 = s_cancel()
+ f4 = h_cancel()
+ f5 = buy_1_cancel()
f6 = sell_cancel()
- dask_result = is_need_cancel(f1, f2, f3, f4, f5, f6)
+ f7 = l_cancel()
+ dask_result = is_need_cancel(f1, f2, f3, f4, f5, f6, f7)
+ if is_first_code:
+ dask_result = is_need_cancel(f3, f4, f7)
+
cancel_data, cancel_msg = dask_result.compute()
+ _start_time = l2_data_log.l2_time(code, tool.get_now_timestamp() - _start_time,
+ "宸蹭笅鍗�-鎾ゅ崟 鍒ゆ柇鏄惁闇�瑕佹挙鍗�")
+
if cancel_data:
- cls.debug(code, "瑙﹀彂鎾ゅ崟锛屾挙鍗曚綅缃細{} 锛屾挙鍗曞師鍥狅細{}", cancel_data["index"], cancel_msg)
+ l2_log.debug(code, "瑙﹀彂鎾ゅ崟锛屾挙鍗曚綅缃細{} 锛屾挙鍗曞師鍥狅細{}", cancel_data["index"], cancel_msg)
+ l2_log.trade_record(code, "鎾ゅ崟", "'index':{} , 'msg':'{}'", cancel_data["index"], cancel_msg)
# 鎾ゅ崟
if cls.cancel_buy(code, cancel_msg):
+ _start_time = l2_data_log.l2_time(code, tool.get_now_timestamp() - _start_time,
+ "宸蹭笅鍗�-鎾ゅ崟 鑰楁椂")
# 鎾ゅ崟鎴愬姛锛岀户缁绠椾笅鍗�
- cls.__process_not_order(code, cancel_data["index"] + 1, end_index, capture_time)
+ cls.__process_not_order(code, cancel_data["index"] + 1, end_index, capture_time, is_first_code)
+ _start_time = l2_data_log.l2_time(code, tool.get_now_timestamp() - _start_time,
+ "澶勭悊鍓╀綑鏁版嵁 鑰楁椂")
else:
# 鎾ゅ崟灏氭湭鎴愬姛
pass
- _start_time = l2_data_log.l2_time(code, cls.random_key[code], round(t.time() * 1000) - _start_time,
- "宸蹭笅鍗�-鎾ゅ崟+澶勭悊鍓╀綑鏁版嵁")
-
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)
+ l2_log.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])
- _start_time = l2_data_log.l2_time(code, cls.random_key[code], round(t.time() * 1000) - _start_time,
- "宸蹭笅鍗�-鐪熷疄涓嬪崟")
+ unreal_buy_info[0], is_first_code)
+ _start_time = l2_data_log.l2_time(code, tool.get_now_timestamp() - _start_time,
+ "宸茶櫄鎷熶笅鍗�-鎵ц鐪熷疄涓嬪崟 澶栭儴鑰楁椂")
@classmethod
- def __buy(cls, code, capture_timestamp, last_data, last_data_index):
- can, reason = cls.__can_buy(code)
+ def __buy(cls, code, capture_timestamp, last_data, last_data_index, is_first_code):
+ __start_time = tool.get_now_timestamp()
+ can, need_clear_data, reason = False, False, ""
+ if not is_first_code:
+ can, need_clear_data, reason = cls.__can_buy(code)
+ else:
+ can, need_clear_data, reason = cls.__can_buy_first(code)
+ __start_time = l2_data_log.l2_time(code, tool.get_now_timestamp() - __start_time, "鏈�鍚庡垽鏂槸鍚﹁兘涓嬪崟", force=True)
# 鍒犻櫎铏氭嫙涓嬪崟
if code in cls.unreal_buy_dict:
cls.unreal_buy_dict.pop(code)
+ buy_single_index, buy_exec_index, buy_compute_index, num, count, max_num_set, buy_volume_rate = cls.__get_order_begin_pos(
+ code)
if not can:
- cls.debug(code, "涓嶅彲浠ヤ笅鍗曪紝鍘熷洜锛歿}", reason)
- if not reason.startswith("涔�1浠蜂笉涓烘定鍋滀环"):
- # 涓柇涔板叆
- trade_manager.break_buy(code, reason)
+ l2_log.debug(code, "涓嶅彲浠ヤ笅鍗曪紝鍘熷洜锛歿}", reason)
+ if need_clear_data:
+ trade_result_manager.real_cancel_success(code, buy_single_index, buy_exec_index,
+ local_today_datas.get(code))
return
else:
- cls.debug(code, "鍙互涓嬪崟锛屽師鍥狅細{}", reason)
+ l2_log.debug(code, "鍙互涓嬪崟锛屽師鍥狅細{}", reason)
+
try:
- cls.debug(code, "寮�濮嬫墽琛屼拱鍏�")
+ l2_log.debug(code, "寮�濮嬫墽琛屼拱鍏�")
trade_manager.start_buy(code, capture_timestamp, last_data,
last_data_index)
################涓嬪崟鎴愬姛澶勭悊################
trade_result_manager.real_buy_success(code)
- cls.debug(code, "鎵ц涔板叆鎴愬姛")
+ l2_log.debug(code, "鎵ц涔板叆鎴愬姛")
+ params_desc = cls.__l2PlaceOrderParamsManagerDict[code].get_buy_rank_desc()
+ l2_log.debug(code, params_desc)
+ l2_log.trade_record(code, "涓嬪崟",
+ "'buy_start_index':{} ,'buy_exec_index':{},'volume_reate':{},'score':{},'desc':'{}'",
+ buy_single_index, buy_exec_index, cls.volume_rate_info[code][0],
+ cls.__l2PlaceOrderParamsManagerDict[code].score, params_desc)
except Exception as e:
- cls.debug(code, "鎵ц涔板叆寮傚父:{}", str(e))
+ logger_l2_error.exception(e)
+ l2_log.debug(code, "鎵ц涔板叆寮傚父:{}", str(e))
pass
finally:
- cls.debug(code, "m鍊煎奖鍝嶅洜瀛愶細{}", l2_trade_factor.L2TradeFactorUtil.factors_to_string(code))
+ l2_log.debug(code, "m鍊煎奖鍝嶅洜瀛愶細{}", l2_trade_factor.L2TradeFactorUtil.factors_to_string(code))
# 鏄惁鍙互鍙栨秷
@classmethod
def __can_cancel(cls, code):
if constant.TEST:
return True, ""
+ if l2_trade_util.WhiteListCodeManager.is_in(code):
+ return False, "浠ｇ爜鍦ㄧ櫧鍚嶅崟涓�"
+
# 鏆傛椂娉ㄩ噴鎺�
# 14鐐瑰悗濡傛灉鏄澘鍧楄�佸ぇ灏变笉闇�瑕佸彇娑堜簡
# now_time_str = tool.get_now_time_str()
@@ -489,9 +601,23 @@
return True, ""
# 鏄惁鍙互涔�
+ # 杩斿洖鏄惁鍙互涔�,鏄惁闇�瑕佹竻闄や箣鍓嶇殑涔板叆淇℃伅锛屽師鍥�
@classmethod
def __can_buy(cls, code):
__start_time = t.time()
+ if not trade_manager.TradeStateManager.is_can_buy():
+ return False, True, f"浠婃棩宸茬姝氦鏄�"
+ # 涔嬪墠鐨勪唬鐮�
+ # 棣栨澘浠ｇ爜涓斿皻鏈定鍋滆繃鐨勪笉鑳戒笅鍗�
+ # is_limited_up = gpcode_manager.FirstCodeManager.is_limited_up(code)
+ # if not is_limited_up:
+ # gpcode_manager.FirstCodeManager.add_limited_up_record([code])
+ # place_order_count = trade_data_manager.placeordercountmanager.get_place_order_count(
+ # code)
+ # if place_order_count == 0:
+ # trade_data_manager.placeordercountmanager.place_order(code)
+ # return False, True, "棣栨澘浠ｇ爜锛屼笖灏氭湭娑ㄥ仠杩�"
+
try:
# 涔�1浠锋牸蹇呴』涓烘定鍋滀环鎵嶈兘涔�
# buy1_price = cls.buy1PriceManager.get_price(code)
@@ -504,13 +630,16 @@
# return False, "涔�1浠蜂笉涓烘定鍋滀环锛屼拱1浠�-{} 娑ㄥ仠浠�-{}".format(buy1_price, limit_up_price)
# 浠庝拱鍏ヤ俊鍙疯捣濮嬬偣鍒板綋鍓嶆暟鎹湯灏剧殑绾拱鎵嬫暟涓庡綋鍓嶇殑鍗�1鍋氭瘮杈冿紝濡傛灉姣斿崠1灏忓垯涓嶈兘涔板叆
total_datas = local_today_datas[code]
+ if total_datas[-1]["index"] + 1 > len(total_datas):
+ return False, True, "L2鏁版嵁閿欒"
+
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)
+ l2_log.buy_debug(code, "鍗�1淇℃伅涓猴細({},{},{})", sell1_time, sell1_price, sell1_volumn)
if sell1_time is not None and sell1_volumn > 0:
# 鑾峰彇鎵ц浣嶄俊鎭�
- buy_single_index, buy_exec_index, buy_compute_index, num, count, max_num_set = cls.__get_order_begin_pos(
+ buy_single_index, buy_exec_index, buy_compute_index, num, count, max_num_set, buy_volume_rate = cls.__get_order_begin_pos(
code)
buy_nums = num
for i in range(buy_exec_index + 1, total_datas[-1]["index"] + 1):
@@ -522,30 +651,34 @@
elif L2DataUtil.is_limit_up_price_buy_cancel(_val):
buy_nums -= _val["num"] * total_datas[i]["re"]
if buy_nums < sell1_volumn * 0.49:
- return False, "绾拱閲�({})灏忎簬鍗�1閲忕殑49%{} 鍗�1鏃堕棿锛歿}".format(buy_nums, sell1_volumn, sell1_time)
+ return False, False, "绾拱閲�({})灏忎簬鍗�1閲忕殑49%{} 鍗�1鏃堕棿锛歿}".format(buy_nums, sell1_volumn, sell1_time)
except Exception as e:
logging.exception(e)
# 閲忔瘮瓒呰繃1.3鐨勪笉鑳戒拱
- volumn_rate = l2_trade_factor.L2TradeFactorUtil.get_volumn_rate_by_code(code)
+ volumn_rate = cls.volume_rate_info[code][0]
if volumn_rate >= 1.3:
- return False, "鏈�澶ч噺姣旇秴杩�1.3涓嶈兘涔�"
+ return False, False, "鏈�澶ч噺姣旇秴杩�1.3涓嶈兘涔�"
limit_up_time = limit_up_time_manager.get_limit_up_time(code)
- if limit_up_time is not None and l2.l2_data_util.L2DataUtil.get_time_as_second(
- limit_up_time) >= l2.l2_data_util.L2DataUtil.get_time_as_second(
- "14:30:00"):
- return False, "14:30鍚庢定鍋滅殑涓嶈兘涔帮紝娑ㄥ仠鏃堕棿涓簕}".format(limit_up_time)
+ if limit_up_time is not None:
+ limit_up_time_seconds = l2.l2_data_util.L2DataUtil.get_time_as_second(
+ limit_up_time)
+ if limit_up_time_seconds >= l2.l2_data_util.L2DataUtil.get_time_as_second(
+ "13:00:00"):
+ return False, False, "浜屾澘涓嬪崍娑ㄥ仠鐨勪笉鑳戒拱锛屾定鍋滄椂闂翠负{}".format(limit_up_time)
+ if limit_up_time_seconds >= l2.l2_data_util.L2DataUtil.get_time_as_second("14:55:00"):
+ return False, False, "14:55鍚庢定鍋滅殑涓嶈兘涔帮紝娑ㄥ仠鏃堕棿涓簕}".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, "娌℃湁鑾峰彇鍒拌涓�"
+ return True, False, "娌℃湁鑾峰彇鍒拌涓�"
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, "鍚屼竴鏉垮潡涓�佷笁,鑰佸洓,...涓嶈兘涔�"
+ return False, False, "鍚屼竴鏉垮潡涓�佷笁,鑰佸洓,...涓嶈兘涔�"
if cls.__codeActualPriceProcessor.is_under_water(code, total_datas[-1]["val"]["time"]):
# 姘翠笅鎹炰笖鏉垮潡涓殑绁ㄥ皬浜�16涓嶈兘涔�
@@ -557,7 +690,7 @@
# 鑾峰彇鑰佸ぇ鐨勫競鍊�
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, "姘翠笅鎹烇紝涓嶆槸鑰佸ぇ锛屼笖鑷敱娴侀�氬競鍊煎ぇ浜庤�佸ぇ"
+ return False, False, "姘翠笅鎹烇紝涓嶆槸鑰佸ぇ锛屼笖鑷敱娴侀�氬競鍊煎ぇ浜庤�佸ぇ"
# 13:30鍚庢定鍋滐紝鏈澘鍧椾腑娑ㄥ仠绁ㄦ暟<29涓嶈兘涔�
# if limit_up_time is not None:
@@ -593,26 +726,168 @@
# if global_util.industry_hot_num.get(industry) < 29:
# return False, "鑰佷簩锛屾湰鏉垮潡涓定鍋滅エ鏁�<29涓嶈兘涔�"
# 鍙互涓嬪崟
- return True, None
+ return True, False, None
finally:
- l2_data_log.l2_time(code, cls.random_key[code], round((t.time() - __start_time) * 1000), "鏄惁鍙互涓嬪崟璁＄畻")
+ l2_data_log.l2_time(code, round((t.time() - __start_time) * 1000), "鏄惁鍙互涓嬪崟璁＄畻")
+
+ @classmethod
+ def __can_buy_first(cls, code):
+ if not trade_manager.TradeStateManager.is_can_buy():
+ return False, True, f"浠婃棩宸茬姝氦鏄�"
+
+ if gpcode_manager.PauseBuyCodesManager.is_in(code):
+ return False, True, f"璇ヤ唬鐮佽鏆傚仠浜ゆ槗"
+
+ limit_up_price = gpcode_manager.get_limit_up_price(code)
+
+ if float(limit_up_price) >= 40:
+ return False, True, "鑲′环澶т簬40鍧�"
+
+ if constant.L2_SOURCE_TYPE == constant.L2_SOURCE_TYPE_HUAXIN:
+ trade_price = current_price_process_manager.get_trade_price(code)
+ if trade_price is None:
+ return False, True, f"灏氭湭鑾峰彇鍒板綋鍓嶆垚浜や环"
+ if float(limit_up_price) - float(trade_price) > 0.02001:
+ return False, False, f"褰撳墠鎴愪氦浠凤紙{trade_price}锛夊皻鏈湪2妗ｅ強浠ュ唴"
+
+ # 鍒ゆ柇鎴愪氦杩涘害鏄惁璺濈鎴戜滑鐨勪綅缃緢杩�
+ total_data = local_today_datas.get(code)
+ trade_index, is_default = cls.__TradeBuyQueue.get_traded_index(code)
+ if not is_default and trade_index:
+ buy_index_set = set()
+ num_operate_map = local_today_num_operate_map.get(code)
+ for i in range(trade_index + 1, total_data[-1]["index"] + 1):
+ if L2DataUtil.is_limit_up_price_buy(total_data[i]["val"]):
+ left_count = l2_data_source_util.L2DataSourceUtils.get_limit_up_buy_no_canceled_count(code,
+ total_data[
+ i][
+ "index"],
+ total_data,
+ num_operate_map)
+ if left_count > 0:
+ buy_index_set.add(total_data[i]["index"])
+
+ if len(buy_index_set) < 5:
+ return False, False, f"鎴愪氦浣嶇疆璺濈褰撳墠浣嶇疆灏忎簬5绗�"
+ else:
+ # 鍒ゆ柇涔�1浠锋牸妗ｄ綅
+ zyltgb = global_util.zyltgb_map.get(code)
+ if zyltgb is None:
+ global_data_loader.load_zyltgb()
+ zyltgb = global_util.zyltgb_map.get(code)
+
+ if zyltgb >= 200 * 100000000:
+ buy1_price = code_price_manager.Buy1PriceManager.get_buy1_price(code)
+ if buy1_price is None:
+ return False, True, f"灏氭湭鑾峰彇鍒颁拱1浠�"
+ dif = float(limit_up_price) - float(buy1_price)
+ # 澶т簬10妗�
+ if dif > 0.10001:
+ return False, True, f"鑷敱娴侀��200浜夸互涓婏紝涔�1鍓╀綑妗ｆ暟澶т簬10妗ｏ紝涔颁竴锛坽buy1_price}锛夋定鍋滐紙{limit_up_price}锛�"
+
+ open_limit_up_lowest_price = code_price_manager.Buy1PriceManager.get_open_limit_up_lowest_price(code)
+ price_pre_close = gpcode_manager.get_price_pre(code)
+ if open_limit_up_lowest_price and (
+ float(open_limit_up_lowest_price) - price_pre_close) / price_pre_close < 0.05:
+ return False, True, f"鐐告澘鍚庢渶浣庝环璺岃嚦5%浠ヤ笅"
+
+ limit_up_info = code_price_manager.Buy1PriceManager.get_limit_up_info(code)
+ if limit_up_info[0] is None and False:
+ total_data = local_today_datas.get(code)
+ buy_single_index, buy_exec_index, buy_compute_index, num, count, max_num_set, buy_volume_rate = cls.__get_order_begin_pos(
+ code)
+ # 涔嬪墠娌℃湁娑ㄥ仠杩�
+ # 缁熻涔板叆淇″彿浣嶅埌褰撳墠浣嶇疆娌℃湁鎾ょ殑澶у崟閲戦
+ min_money_w = l2_data_util.get_big_money_val(float(total_data[buy_single_index]["val"]["price"])) // 10000
+ left_big_num = l2.cancel_buy_strategy.SecondCancelBigNumComputer.compute_left_big_num(code,
+ buy_single_index,
+ buy_exec_index,
+ total_data[-1][
+ "index"],
+ total_data,
+ 0, min_money_w)
+ if left_big_num > 0:
+ # 閲嶆柊鑾峰彇鍒嗘暟涓庡垎鏁扮储寮�
+ limit_up_time = limit_up_time_manager.get_limit_up_time(code)
+ if limit_up_time is None:
+ limit_up_time = tool.get_now_time_str()
+ score = first_code_score_manager.get_score(code, cls.volume_rate_info[code][0], limit_up_time, True,
+ left_big_num)
+ cls.__l2PlaceOrderParamsManagerDict[code].set_score(score)
+
+ logger_place_order_score.info("code={},data='score_index':{},'score_info':{}", code,
+ cls.__l2PlaceOrderParamsManagerDict[code].score_index,
+ cls.__l2PlaceOrderParamsManagerDict[code].score_info)
+
+ if not gpcode_manager.WantBuyCodesManager.is_in(code):
+ if TradeTargetCodeModeManager.get_mode() == TradeTargetCodeModeManager.MODE_ONLY_BUY_WANT_CODES:
+ return False, True, f"鍙拱鎯充拱鍗曚腑鐨勪唬鐮�"
+ score_index = cls.__l2PlaceOrderParamsManagerDict[code].score_index
+ score = cls.__l2PlaceOrderParamsManagerDict[code].score
+ score_info = cls.__l2PlaceOrderParamsManagerDict[code].score_info
+ return cls.can_buy_first(code, limit_up_price, score_index, score, score_info, cls.volume_rate_info[code])
+ else:
+ return True, False, "鍦ㄦ兂涔板悕鍗曚腑"
+
+ @classmethod
+ def can_buy_first(cls, code, limit_up_price, score_index, score, score_info, volume_rate_info):
+ def is_has_k_format(score_info):
+ # (15涓氦鏄撴棩娑ㄥ箙鏄惁澶т簬24.9%,鏄惁鐮村墠楂橈紝鏄惁瓒呰穼锛屾槸鍚︽帴杩戝墠楂橈紝鏄惁N,鏄惁V,鏄惁鏈夊舰鎬�,澶╅噺澶ч槼淇℃伅,鏄惁鍏锋湁杈ㄨ瘑搴�)
+
+ if score_info[1][3][6][0] and not score_info[1][3][3][0]:
+ return True
+ if score_info[1][3][7][0]:
+ return True
+ return False
+
+ if float(limit_up_price) >= 40:
+ return False, True, "鑲′环澶т簬40鍧�"
+
+ # 9:35涔嬪墠涔板ぇ甯傚��(>=80浜�)绁�
+ if int(tool.get_now_date_str("%Y%m%d")) < int("093500"):
+ zyltgb = global_util.zyltgb_map.get(code)
+ if zyltgb is None:
+ global_data_loader.load_zyltgb()
+ zyltgb = global_util.zyltgb_map.get(code)
+ if zyltgb >= 80 * 100000000:
+ return True, False, "{9:30:00-9:35:00}鑷敱甯傚�尖墺80浜�"
+ # 鍒ゆ柇鏉垮潡
+ plate_can_buy, msg = CodePlateKeyBuyManager.can_buy(code,
+ kpl_data_manager.KPLLimitUpDataRecordManager.latest_origin_datas,
+ kpl_data_manager.KPLLimitUpDataRecordManager.total_datas,block_info.get_before_blocks_dict())
+ if not plate_can_buy:
+ return False, True, msg
+ return True, False, msg
+
+ # if volume_rate_info[0] < 0.4:
+ # return False, True, f"閲忓ぇ浜�40%鎵嶄笅鍗�,閲忔瘮锛歿volume_rate_info[0]}"
+
+ # 鏄惁鏈塊绾垮舰鎬�(鏈塊绾垮舰鎬佹垨鑰呭ぉ閲忓ぇ闃�),10鐐瑰悗鎵嶉渶瑕佸垽鏂槸鍚︽湁K绾垮舰鎬佷笌鍒嗗��
+ if int(tool.get_now_time_str().replace(":", "")) > int("100000"):
+ has_k_format = score_info[1][3][6][0] or score_info[1][3][7][0]
+ if not has_k_format:
+ return False, True, f"鏃燢绾垮舰鎬�"
+
+ if score_index < 0:
+ return False, True, f"鍒嗗�硷細{score}鏈揪鍒伴渶瑕佷拱鍏ョ殑鍒嗘暟绾�"
+ return True, False, ""
@classmethod
def __cancel_buy(cls, code):
try:
- cls.debug(code, "寮�濮嬫墽琛屾挙鍗�")
+ l2_log.debug(code, "寮�濮嬫墽琛屾挙鍗�")
trade_manager.start_cancel_buy(code)
- cls.debug(code, "鎵ц鎾ゅ崟鎴愬姛")
+ l2_log.debug(code, "鎵ц鎾ゅ崟鎴愬姛")
return True
except Exception as e:
logging.exception(e)
- cls.debug(code, "鎵ц鎾ゅ崟寮傚父锛歿}", str(e))
+ l2_log.debug(code, "鎵ц鎾ゅ崟寮傚父锛歿}", str(e))
return False
@classmethod
def cancel_buy(cls, code, msg=None, source="l2"):
# 鏄惁鏄氦鏄撻槦鍒楄Е鍙�
- buy_single_index, buy_exec_index, buy_compute_index, num, count, max_num_set = cls.__get_order_begin_pos(
+ buy_single_index, buy_exec_index, buy_compute_index, num, count, max_num_set, buy_volume_rate = cls.__get_order_begin_pos(
code)
total_datas = local_today_datas[code]
if source == "trade_queue":
@@ -630,13 +905,13 @@
can_cancel, reason = cls.__can_cancel(code)
if not can_cancel:
# 涓嶈兘鍙栨秷
- cls.cancel_debug(code, "鎾ゅ崟涓柇锛屽師鍥狅細{}", reason)
- cls.debug(code, "鎾ゅ崟涓柇锛屽師鍥狅細{}", reason)
+ l2_log.cancel_debug(code, "鎾ゅ崟涓柇锛屽師鍥狅細{}", reason)
+ l2_log.debug(code, "鎾ゅ崟涓柇锛屽師鍥狅細{}", reason)
return False
cancel_result = cls.__cancel_buy(code)
if cancel_result:
trade_result_manager.real_cancel_success(code, buy_single_index, buy_exec_index, total_datas)
- cls.debug(code, "鎵ц鎾ゅ崟缁撴潫锛屽師鍥狅細{}", msg)
+ l2_log.debug(code, "鎵ц鎾ゅ崟缁撴潫锛屽師鍥狅細{}", msg)
return True
# 铏氭嫙涓嬪崟
@@ -647,86 +922,119 @@
@classmethod
def __start_compute_buy(cls, code, compute_start_index, compute_end_index, threshold_money, capture_time,
+ is_first_code,
new_add=True):
if compute_end_index < compute_start_index:
return
- _start_time = round(t.time() * 1000)
+ _start_time = tool.get_now_timestamp()
total_datas = local_today_datas[code]
# 澶勭悊瀹夊叏绗旀暟
cls.__buyL2SafeCountManager.compute_left_rate(code, compute_start_index, compute_end_index, total_datas,
local_today_num_operate_map.get(code))
# 鑾峰彇涔板叆淇″彿璁＄畻璧峰浣嶇疆
- buy_single_index, buy_exec_index, buy_compute_index, num, count, max_num_set = cls.__get_order_begin_pos(
+ buy_single_index, buy_exec_index, buy_compute_index, num, count, max_num_set, buy_volume_rate = cls.__get_order_begin_pos(
code)
# 鏄惁涓烘柊鑾峰彇鍒扮殑浣嶇疆
+ new_get_single = False
if buy_single_index is None:
- place_order_count = trade_data_manager.placeordercountmanager.get_place_order_count(code)
- continue_count = 3
- # 鍓�2娆＄殑淇″彿杩炵画绗旀暟涓�3锛屽悗闈负2
- if place_order_count > 2:
- continue_count = 2
+ continue_count = cls.__l2PlaceOrderParamsManagerDict[code].get_begin_continue_buy_count()
# 鏈変拱鍏ヤ俊鍙�
has_single, _index = cls.__compute_order_begin_pos(code, max(
(compute_start_index - continue_count - 1) if new_add else compute_start_index, 0), continue_count,
compute_end_index)
+ # 濡傛灉涔板叆淇″彿涓庝笂娆＄殑涔板叆淇″彿涓�鏍峰氨涓嶈兘绠楁柊鐨勪俊鍙�
+ if cls.__last_buy_single_dict.get(code) == _index:
+ has_single = None
+ _index = None
+
buy_single_index = _index
if has_single:
+ cls.__last_buy_single_dict[code] = buy_single_index
+ new_get_single = True
num = 0
count = 0
- cls.debug(code, "鑾峰彇鍒颁拱鍏ヤ俊鍙疯捣濮嬬偣锛歿} ,璁＄畻鑼冨洿锛歿}-{} 锛屾暟鎹細{}", buy_single_index, compute_start_index,
- compute_end_index, total_datas[buy_single_index])
+ l2_log.debug(code, "鑾峰彇鍒颁拱鍏ヤ俊鍙疯捣濮嬬偣锛歿} ,璁＄畻鑼冨洿锛歿}-{} 锛岄噺姣旓細{}锛屾暟鎹細{}", buy_single_index, compute_start_index,
+ compute_end_index, cls.volume_rate_info[code], total_datas[buy_single_index])
# 濡傛灉鏄粖澶╃涓�娆℃湁涓嬪崟寮�濮嬩俊鍙凤紝闇�瑕佽缃ぇ鍗曡捣濮嬬偣
cls.l2BigNumForMProcessor.set_begin_pos(code, buy_single_index)
- _start_time = l2_data_log.l2_time(code, cls.random_key[code], round(t.time() * 1000) - _start_time, "涓嬪崟淇″彿璁＄畻鏃堕棿")
+ _start_time = l2_data_log.l2_time(code, tool.get_now_timestamp() - _start_time, "涓嬪崟淇″彿璁＄畻鏃堕棿")
if buy_single_index is None:
# 鏈幏鍙栧埌涔板叆淇″彿锛岀粓姝㈢▼搴�
return None
+ # 寮�濮嬭绠楃殑浣嶇疆
+ start_process_index = max(buy_single_index, compute_start_index)
+ if new_get_single:
+ start_process_index = buy_single_index
+
# 璁＄畻m鍊煎ぇ鍗�
- cls.l2BigNumForMProcessor.process(code, max(buy_single_index, compute_start_index), compute_end_index,
+ cls.l2BigNumForMProcessor.process(code, start_process_index,
+ compute_end_index,
gpcode_manager.get_limit_up_price(code))
- _start_time = l2_data_log.l2_time(code, cls.random_key[code], round(t.time() * 1000) - _start_time, "璁＄畻m鍊煎ぇ鍗�")
+ _start_time = l2_data_log.l2_time(code, tool.get_now_timestamp() - _start_time, "璁＄畻m鍊煎ぇ鍗�")
threshold_money, msg = cls.__get_threshmoney(code)
- # 涔板叆绾拱棰濈粺璁�
- 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, cls.random_key[code], round(t.time() * 1000) - _start_time, "绾拱棰濈粺璁℃椂闂�")
- cls.debug(code, "m鍊�-{} m鍊煎洜瀛�-{}", threshold_money, msg)
+ _start_time = l2_data_log.l2_time(code, tool.get_now_timestamp() - _start_time, "m鍊奸槇鍊艰绠�")
+
+ # 涔板叆绾拱棰濈粺璁�
+ compute_index, buy_nums, buy_count, rebegin_buy_pos, max_num_set_new = cls.__sum_buy_num_for_order_3(code,
+ start_process_index,
+ compute_end_index,
+ num, count,
+ threshold_money,
+ buy_single_index,
+ max_num_set)
+ _start_time = l2_data_log.l2_time(code, tool.get_now_timestamp() - _start_time, "绾拱棰濈粺璁℃椂闂�")
+
+ l2_log.debug(code, "m鍊�-{} 閲忔瘮:{}", threshold_money, cls.volume_rate_info[code][0])
# 涔板叆淇″彿浣嶄笌璁＄畻浣嶇疆闂撮殧2s鍙婁互涓婁簡
if rebegin_buy_pos is not None:
# 闇�瑕侀噸鏂拌绠楃函涔伴
- cls.__start_compute_buy(code, rebegin_buy_pos, compute_end_index, threshold_money, capture_time, False)
+ cls.__start_compute_buy(code, rebegin_buy_pos, compute_end_index, threshold_money, capture_time,
+ is_first_code, False)
return
if compute_index is not None:
- cls.debug(code, "鑾峰彇鍒颁拱鍏ユ墽琛屼綅缃細{} m鍊硷細{} 绾拱鎵嬫暟锛歿} 绾拱鍗曟暟锛歿} 鏁版嵁锛歿}", compute_index, threshold_money, buy_nums,
- buy_count,
- total_datas[compute_index])
- # 璁板綍涔板叆淇″彿浣嶇疆
- cls.__save_order_begin_data(code, buy_single_index, compute_index, compute_index, buy_nums, buy_count,
- max_num_set_new)
- # 濡傛灉鏄粖澶╃涓�娆℃湁涓嬪崟鎵ц淇″彿锛屾定鍋滄椂闂达紙涔板叆鎵ц浣嶆椂闂达級
- limit_up_time_manager.save_limit_up_time(code, total_datas[compute_index]["val"]["time"])
- # 铏氭嫙涓嬪崟
- cls.__virtual_buy(code, buy_single_index, compute_index, capture_time)
- # 鍒犻櫎涔嬪墠鐨勬墍鏈夋挙鍗曚俊鍙�
- l2_data_manager.TradePointManager.delete_buy_cancel_point(code)
+ l2_log.debug(code, "鑾峰彇鍒颁拱鍏ユ墽琛屼綅缃細{} m鍊硷細{} 绾拱鎵嬫暟锛歿} 绾拱鍗曟暟锛歿} 鏁版嵁锛歿} ,閲忔瘮:{} ", compute_index, threshold_money,
+ buy_nums,
+ buy_count, total_datas[compute_index], cls.volume_rate_info[code])
- # 娑ㄥ仠灏佸崟棰濊绠�
- L2LimitUpMoneyStatisticUtil.process_data(cls.random_key[code], code, buy_single_index, compute_index,
- buy_single_index,
- buy_exec_index, False)
+ f1 = dask.delayed(cls.__save_order_begin_data)(code, buy_single_index, compute_index, compute_index,
+ buy_nums, buy_count, max_num_set_new,
+ cls.volume_rate_info[code][0])
+ f2 = dask.delayed(limit_up_time_manager.save_limit_up_time)(code, total_datas[compute_index]["val"]["time"])
+ f3 = dask.delayed(cls.__virtual_buy)(code, buy_single_index, compute_index, capture_time)
+ f4 = dask.delayed(l2_data_manager.TradePointManager.delete_buy_cancel_point)(code)
+ f5 = dask.delayed(L2LimitUpMoneyStatisticUtil.process_data)(code, buy_single_index,
+ compute_index,
+ buy_single_index,
+ buy_exec_index, False)
+ dask.compute(f1, f2, f3, f4, f5)
- _start_time = l2_data_log.l2_time(code, cls.random_key[code], round(t.time() * 1000) - _start_time,
+ # 宸茶骞惰澶勭悊
+ # # 璁板綍涔板叆淇″彿浣嶇疆
+ # cls.__save_order_begin_data(code, buy_single_index, compute_index, compute_index, buy_nums, buy_count,
+ # max_num_set_new)
+ # # 濡傛灉鏄粖澶╃涓�娆℃湁涓嬪崟鎵ц淇″彿锛屾定鍋滄椂闂达紙涔板叆鎵ц浣嶆椂闂达級
+ # limit_up_time_manager.save_limit_up_time(code, total_datas[compute_index]["val"]["time"])
+ # # 铏氭嫙涓嬪崟
+ # cls.__virtual_buy(code, buy_single_index, compute_index, capture_time)
+ # # 鍒犻櫎涔嬪墠鐨勬墍鏈夋挙鍗曚俊鍙�
+ # l2_data_manager.TradePointManager.delete_buy_cancel_point(code)
+ #
+ # # 娑ㄥ仠灏佸崟棰濊绠�
+ # L2LimitUpMoneyStatisticUtil.process_data(cls.random_key[code], code, buy_single_index, compute_index,
+ # buy_single_index,
+ # buy_exec_index, False)
+
+ _start_time = l2_data_log.l2_time(code, tool.get_now_timestamp() - _start_time,
"璁板綍鎵ц涔板叆鏁版嵁", force=True)
# 鏁版嵁鏄惁澶勭悊瀹屾瘯
@@ -734,36 +1042,40 @@
need_cancel, cancel_data = SecondCancelBigNumComputer.need_cancel(code, buy_single_index,
compute_index,
buy_single_index, compute_index,
- total_datas, cls.random_key[code],
+ total_datas, is_first_code,
+ cls.volume_rate_info[code][1],
+ cls.volume_rate_info[code][1],
True)
- _start_time = l2_data_log.l2_time(code, cls.random_key[code], round(t.time() * 1000) - _start_time,
+ _start_time = l2_data_log.l2_time(code, tool.get_now_timestamp() - _start_time,
"S绾уぇ鍗曞鐞嗚�楁椂", force=True)
- cls.debug(code, "鏁版嵁澶勭悊瀹屾瘯锛屼笅鍗�, 鏁版嵁鎴浘鏃堕棿-{}", capture_time)
+ l2_log.debug(code, "鏁版嵁澶勭悊瀹屾瘯锛屼笅鍗�, 鏁版嵁鎴浘鏃堕棿-{}", capture_time)
# 鏁版嵁宸茬粡澶勭悊瀹屾瘯锛屽鏋滆繕娌℃挙鍗曞氨瀹為檯涓嬪崟
if need_cancel:
if cls.cancel_buy(code, "S绾уぇ鍗曟挙閿�"):
# 鎵ц鎾ゅ崟鎴愬姛
pass
else:
- cls.__buy(code, capture_time, total_datas[compute_index], compute_index)
+ cls.__buy(code, capture_time, total_datas[compute_index], compute_index, is_first_code)
else:
SecondCancelBigNumComputer.need_cancel(code, buy_single_index, compute_index, buy_single_index,
- compute_index, total_datas, cls.random_key[code], False)
+ compute_index, total_datas, is_first_code,
+ cls.volume_rate_info[code][1],
+ cls.volume_rate_info[code][1], False)
- _start_time = l2_data_log.l2_time(code, cls.random_key[code], round(t.time() * 1000) - _start_time,
+ _start_time = l2_data_log.l2_time(code, tool.get_now_timestamp() - _start_time,
"S绾уぇ鍗曞鐞嗚�楁椂", force=True)
# 鏁版嵁灏氭湭澶勭悊瀹屾瘯锛岃繘琛屼笅涓�姝ュ鐞�
- cls.debug(code, "鏁版嵁灏氭湭澶勭悊瀹屾瘯锛岃繘琛屼笅涓�姝ュ鐞嗭紝澶勭悊杩涘害锛歿}", compute_index)
+ l2_log.debug(code, "鏁版嵁灏氭湭澶勭悊瀹屾瘯锛岃繘琛屼笅涓�姝ュ鐞嗭紝澶勭悊杩涘害锛歿}", compute_index)
# 澶勭悊鎾ゅ崟姝ラ
- cls.__process_order(code, compute_index + 1, compute_end_index, capture_time, False)
- _start_time = l2_data_log.l2_time(code, cls.random_key[code], round(t.time() * 1000) - _start_time,
+ cls.__process_order(code, compute_index + 1, compute_end_index, capture_time, is_first_code, False)
+ _start_time = l2_data_log.l2_time(code, tool.get_now_timestamp() - _start_time,
f"澶勭悊鎾ゅ崟姝ラ鑰楁椂锛岃寖鍥达細{compute_index + 1}-{compute_end_index}", force=True)
else:
# 鏈揪鍒颁笅鍗曟潯浠讹紝淇濆瓨绾拱棰濓紝璁剧疆绾拱棰�
# 璁板綍涔板叆淇″彿浣嶇疆
cls.__save_order_begin_data(code, buy_single_index, -1, compute_end_index, buy_nums, buy_count,
- max_num_set_new)
+ max_num_set_new, None)
print("淇濆瓨澶у崟鏃堕棿", round((t.time() - _start_time) * 1000))
_start_time = t.time()
pass
@@ -771,15 +1083,16 @@
# 鑾峰彇涓嬪崟璧峰淇″彿
@classmethod
def __get_order_begin_pos(cls, code):
- buy_single_index, buy_exec_index, compute_index, num, count, max_num_set = l2_data_manager.TradePointManager.get_buy_compute_start_data(
+ buy_single_index, buy_exec_index, compute_index, num, count, max_num_set, volume_rate = l2_data_manager.TradePointManager.get_buy_compute_start_data(
code)
- return buy_single_index, buy_exec_index, compute_index, num, count, max_num_set
+ return buy_single_index, buy_exec_index, compute_index, num, count, max_num_set, volume_rate
# 淇濆瓨涓嬪崟璧峰淇″彿
@classmethod
- def __save_order_begin_data(self, code, buy_single_index, buy_exec_index, compute_index, num, count, max_num_set):
+ def __save_order_begin_data(self, code, buy_single_index, buy_exec_index, compute_index, num, count, max_num_set,
+ volume_rate):
TradePointManager.set_buy_compute_start_data(code, buy_single_index, buy_exec_index, compute_index, num, count,
- max_num_set)
+ max_num_set, volume_rate)
# 璁＄畻涓嬪崟璧峰淇″彿
# compute_data_count 鐢ㄤ簬璁＄畻鐨刲2鏁版嵁鏁伴噺
@@ -795,12 +1108,18 @@
last_index = None
count = 0
start = None
-
+ now_time_s = tool.get_time_as_second(tool.get_now_time_str())
for i in range(start_index, end_index + 1):
_val = datas[i]["val"]
+ time_s = L2DataUtil.get_time_as_second(_val["time"])
# 鏃堕棿瑕�>=09:30:00
- if L2DataUtil.get_time_as_second(_val["time"]) < second_930:
+ if time_s < second_930:
continue
+
+ if not constant.TEST:
+ if abs(now_time_s - time_s) > 2:
+ # 姝ｅ紡鐜涓嬩笉澶勭悊2s澶栫殑鏁版嵁
+ continue
if L2DataUtil.is_limit_up_price_buy(_val):
@@ -827,7 +1146,7 @@
@classmethod
def __get_threshmoney(cls, code):
- return l2_trade_factor.L2TradeFactorUtil.compute_m_value(code)
+ return cls.__l2PlaceOrderParamsManagerDict[code].get_m_val()
# 璁＄畻涓囨墜鍝ョ瑪鏁�
@classmethod
@@ -845,70 +1164,48 @@
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_set):
def get_threshold_count():
- count = threshold_count # - sub_threshold_count
- # if count < 3:
- # count = 3
- # count = round(count * buy1_factor)
- # # 鏈�楂�30绗旓紝鏈�浣�8绗�
- # if count > 21:
- # count = 21
- # if count < 8:
- # count = 8
+ count = threshold_count
return count
_start_time = t.time()
total_datas = local_today_datas[code]
- # 璁＄畻浠庝拱鍏ヤ俊鍙峰紑濮嬪埌璁＄畻寮�濮嬩綅缃殑澶у崟鏁伴噺
- sub_threshold_count = cls.__compute_big_money_count(total_datas, buy_single_index, compute_start_index - 1)
- if sub_threshold_count < 0:
- sub_threshold_count = 0
+ is_first_code = gpcode_manager.FirstCodeManager.is_in_first_record(code)
buy_nums = origin_num
buy_count = origin_count
limit_up_price = gpcode_manager.get_limit_up_price(code)
- buy1_price = cls.buy1PriceManager.get_price(code)
if limit_up_price is None:
raise Exception("娑ㄥ仠浠锋棤娉曡幏鍙�")
# 鐩爣鎵嬫暟
threshold_num = round(threshold_money / (limit_up_price * 100))
- buy1_factor = 1
- # 鑾峰彇涔�1鏄惁涓烘定鍋滀环
- if buy1_price is None:
- buy1_factor = 1.3
- elif limit_up_price is None:
- buy1_factor = 1.3
- elif abs(float(buy1_price) - float(limit_up_price)) >= 0.01:
- print("涔�1浠蜂笉涓烘定鍋滀环锛屼拱1浠�-{} 娑ㄥ仠浠�-{}".format(buy1_price, limit_up_price))
- buy1_factor = 1.3
+ # place_order_count = trade_data_manager.placeordercountmanager.get_place_order_count(code)
# 鐩爣璁㈠崟鏁伴噺
- threshold_count = cls.__buyL2SafeCountManager.get_safe_count(code)
+ threshold_count = cls.__l2PlaceOrderParamsManagerDict[code].get_safe_count()
buy_single_time_seconds = L2DataUtil.get_time_as_second(total_datas[buy_single_index]["val"]["time"])
# 鍙互瑙﹀彂涔帮紝褰撴湁娑ㄥ仠涔颁俊鍙锋椂鎵嶄細瑙﹀彂涔�
trigger_buy = True
- place_order_count = trade_data_manager.placeordercountmanager.get_place_order_count(code)
- if place_order_count > 3:
- place_order_count = 3
+
# 闂撮殧鏈�澶ф椂闂翠緷娆′负锛�3,9,27,81
- max_space_time = pow(3, place_order_count + 1) - 1
+ max_space_time = cls.__l2PlaceOrderParamsManagerDict[code].get_time_range()
# 鏈�澶т拱閲�
max_buy_num = 0
max_buy_num_set = set(max_num_set)
# 闇�瑕佺殑鏈�灏忓ぇ鍗曠瑪鏁�
- big_num_count = 2
- if place_order_count > 1:
- # 绗竴娆′笅鍗曢渶瑕佸ぇ鍗曟渶灏�2绗旓紝浠ュ悗鍙渶瑕�1绗�
- big_num_count = 1
+ big_num_count = cls.__l2PlaceOrderParamsManagerDict[code].get_big_num_count()
+
+ # 杈冨ぇ鍗曠殑鎵嬫暟
+ bigger_num = round(5900 / limit_up_price)
for i in range(compute_start_index, compute_end_index + 1):
data = total_datas[i]
_val = total_datas[i]["val"]
trigger_buy = False
- # 蹇呴』涓鸿繛缁�3绉掑唴鐨勬暟鎹�
- if L2DataUtil.get_time_as_second(_val["time"]) - buy_single_time_seconds > max_space_time:
+ # 蹇呴』涓鸿繛缁�2绉掑唴鐨勬暟鎹�
+ if L2DataUtil.get_time_as_second(_val["time"]) - buy_single_time_seconds + 1 > max_space_time:
TradePointManager.delete_buy_point(code)
if i == compute_end_index:
# 鏁版嵁澶勭悊瀹屾瘯
@@ -921,218 +1218,74 @@
# 娑ㄥ仠涔�
if L2DataUtil.is_limit_up_price_buy(_val):
if l2_data_util.is_big_money(_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 _val["num"] >= bigger_num:
trigger_buy = True
# 鍙粺璁�59涓囦互涓婄殑閲戦
buy_nums += int(_val["num"]) * int(total_datas[i]["re"])
buy_count += int(total_datas[i]["re"])
if buy_nums >= threshold_num and buy_count >= get_threshold_count():
- logger_l2_trade_buy.info("{}鑾峰彇鍒颁拱鍏ユ墽琛岀偣锛歿} 缁熻绾拱鎵嬫暟锛歿} 鐩爣绾拱鎵嬫暟锛歿} 缁熻绾拱鍗曟暟锛歿} 鐩爣绾拱鍗曟暟锛歿}, 澶у崟鏁伴噺锛歿}", code,
- i,
- buy_nums,
- threshold_num, buy_count, get_threshold_count(), sub_threshold_count, )
+ logger_l2_trade_buy.info(
+ f"{code}鑾峰彇鍒颁拱鍏ユ墽琛岀偣锛歿i} 缁熻绾拱鎵嬫暟锛歿buy_nums} 鐩爣绾拱鎵嬫暟锛歿threshold_num} 缁熻绾拱鍗曟暟锛歿buy_count} 鐩爣绾拱鍗曟暟锛歿get_threshold_count()}, 澶у崟鏁伴噺锛歿len(max_buy_num_set)}")
elif L2DataUtil.is_limit_up_price_buy_cancel(_val):
- if l2_data_util.is_big_money(_val):
- sub_threshold_count -= int(total_datas[i]["re"])
- if round(int(_val["num"]) * float(_val["price"])) >= 5900:
+ if _val["num"] >= bigger_num:
# 鍙粺璁�59涓囦互涓婄殑閲戦
# 娑ㄥ仠涔版挙
# 鍒ゆ柇涔板叆浣嶇疆鏄惁鍦ㄤ拱鍏ヤ俊鍙蜂箣鍓�
- buy_index, buy_data = l2_data_util.get_buy_data_with_cancel_data(total_datas[i],
- local_today_num_operate_map.get(
- code))
+ buy_index = l2_data_source_util.L2DataSourceUtils.get_buy_index_with_cancel_data(code,
+ 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"])
buy_count -= int(data["re"])
- cls.buy_debug(code, "{}鏁版嵁鍦ㄤ拱鍏ヤ俊鍙蜂箣鍚� 鎾や拱绾拱鎵嬫暟锛歿} 鐩爣鎵嬫暟锛歿}", i, buy_nums, threshold_num)
+ # 澶у崟鎾ら攢
+ max_buy_num_set.discard(buy_index)
+ l2_log.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"]:
+ l2_log.buy_debug(code, "{}鏁版嵁鍦ㄤ拱鍏ヤ俊鍙蜂箣鍓嶏紝涔板叆浣嶏細{}", i, buy_index)
+ if total_datas[buy_single_index]["val"]["time"] == total_datas[buy_index]["val"]["time"]:
# 鍚屼竴绉�,褰撲綔涔板叆淇″彿涔嬪悗澶勭悊
buy_nums -= int(_val["num"]) * int(data["re"])
buy_count -= int(data["re"])
- cls.buy_debug(code, "{}鏁版嵁涔板叆浣嶄笌棰勪及涔板叆浣嶅湪鍚屼竴绉�", i)
+ # 澶у崟鎾ら攢
+ max_buy_num_set.discard(buy_index)
+ l2_log.buy_debug(code, "{}鏁版嵁涔板叆浣嶄笌棰勪及涔板叆浣嶅湪鍚屼竴绉�", i)
else:
# 鏈壘鍒颁拱鎾ゆ暟鎹殑涔板叆鐐�
- cls.buy_debug(code, "鏈壘鍒颁拱鎾ゆ暟鎹殑涔板叆鐐�: 浣嶇疆-{} 鏁版嵁-{}", i, data)
+ l2_log.buy_debug(code, "鏈壘鍒颁拱鎾ゆ暟鎹殑涔板叆鐐�: 浣嶇疆-{} 鏁版嵁-{}", i, data)
buy_nums -= int(_val["num"]) * int(total_datas[i]["re"])
buy_count -= int(total_datas[i]["re"])
- cls.buy_debug(code, "浣嶇疆-{}锛屾�绘墜鏁帮細{}锛岀洰鏍囨墜鏁帮細{}", i,
- buy_nums, threshold_num)
+ l2_log.buy_debug(code, "浣嶇疆-{}锛屾�绘墜鏁帮細{}锛岀洰鏍囨墜鏁帮細{}", i,
+ buy_nums, threshold_num)
+ max_buy_num_set_count = 0
+ for i in max_buy_num_set:
+ max_buy_num_set_count += total_datas[i]["re"]
# 鏈夋挙鍗曚俊鍙凤紝涓斿皬浜庨槇鍊�
- if buy_nums >= threshold_num and buy_count >= get_threshold_count() and trigger_buy and len(
- max_buy_num_set) >= big_num_count:
+ if buy_nums >= threshold_num and buy_count >= get_threshold_count() and trigger_buy and max_buy_num_set_count >= big_num_count:
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(), len(max_buy_num_set), big_num_count)
+ l2_log.buy_debug(code, "灏氭湭鑾峰彇鍒颁拱鍏ユ墽琛岀偣锛岃捣濮嬭绠椾綅缃細{} 缁熻绾拱鎵嬫暟锛歿} 鐩爣绾拱鎵嬫暟锛歿} 缁熻绾拱鍗曟暟锛歿} 鐩爣绾拱鍗曟暟锛歿} 澶у崟鏁伴噺锛歿} 鐩爣澶у崟鏁伴噺锛歿}",
+ compute_start_index,
+ buy_nums,
+ threshold_num, buy_count, get_threshold_count(), max_buy_num_set_count, big_num_count)
return None, buy_nums, buy_count, None, max_buy_num_set
-
- @classmethod
- def test(cls):
- code = "002556"
- l2_trade_test.clear_trade_data(code)
- load_l2_data(code, True)
-
- _start = t.time()
- if True:
- 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, 1552, 1641, capture_timestamp)
- else:
- # 鏈寕鍗�
- cls.__process_not_order(code, 1552, 1641, capture_timestamp)
- except Exception as e:
- logging.exception(e)
- print("澶勭悊鏃堕棿", round((t.time() - _start) * 1000))
- return
-
- # 鎸塻鎵归噺鍖栨暟鎹�
- total_datas = local_today_datas.get(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 = "002556"
- l2_trade_test.clear_trade_data(code)
- local_latest_datas[code] = []
- load_l2_data(code, True)
- _start = t.time()
- capture_timestamp = 1999999999
- cls.process(code, local_today_datas[code][1552:1641], capture_timestamp)
- print("鏃堕棿鑺辫垂:", round((t.time() - _start) * 1000))
- pass
-
- @classmethod
- def test2(cls):
- code = "002864"
- load_l2_data(code)
- limit_up_time_manager.load_limit_up_time()
- limit_up_time = limit_up_time_manager.get_limit_up_time(code)
- if limit_up_time is not None and l2.l2_data_util.L2DataUtil.get_time_as_second(
- limit_up_time) >= l2.l2_data_util.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, "鍚屼竴鏉垮潡涓�佷笁,鑰佸洓,...涓嶈兘涔�"
-
- if cls.__codeActualPriceProcessor.is_under_water(code):
- # 姘翠笅鎹炰笖鏉垮潡涓殑绁ㄥ皬浜�21涓嶈兘涔�
- 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))
-
- # 13:30鍚庢定鍋滐紝鏈澘鍧椾腑娑ㄥ仠绁ㄦ暟<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(":", "")) >= 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:
- # ----姝ゆ潯娉ㄩ噴-----
- # 濡傛灉鑰佸ぇ宸茬粡涔版垚鍔熶簡锛岃�佷簩灏变笉闇�瑕佷拱浜�
- # first_codes = []
- # for key in codes_index:
- # if codes_index.get(key) == 0:
- # first_codes.append(key)
- #
- # for key in first_codes:
- # state = trade_manager.get_trade_state(key)
- # if state == trade_manager.TRADE_STATE_BUY_SUCCESS:
- # # 鑰佸ぇ宸茬粡涔版垚鍔熶簡
- # return False, "鑰佸ぇ{}宸茬粡涔版垚鍔燂紝鑰佷簩鏃犻渶璐拱".format(key)
- # ----姝ゆ潯娉ㄩ噴-----
-
- # ----姝ゆ潯娉ㄩ噴-----
- # 鏈�9鐐瑰崐娑ㄥ仠鐨勮�佸ぇ鎵嶈兘涔拌�佷簩锛屼笉鐒朵笉鑳戒拱
- # 鑾峰彇鑰佸ぇ鐨勬定鍋滄椂闂�
- # for key in first_codes:
- # # 鎵惧埌浜嗚�佸ぇ
- # time_ = limit_up_time_manager.get_limit_up_time(key)
- # if time_ == "09:30:00":
- # return True, "9:30娑ㄥ仠鐨勮�佸ぇ锛岃�佷簩鍙互涓嬪崟"
- # return False, "鑰佸ぇ闈�9:30娑ㄥ仠锛岃�佷簩涓嶈兘涓嬪崟"
- # ----姝ゆ潯娉ㄩ噴-----
-
- return True, "鑰佷簩鍙互涓嬪崟"
-
- @classmethod
- def test3(cls):
- code = "002094"
- load_l2_data(code, True)
- cls.random_key[code] = random.randint(0, 100000)
- buy_single_begin_index, buy_exec_index = 426, 479
-
- L2LimitUpMoneyStatisticUtil.process_data(cls.random_key[code], code, 480, 519,
- buy_single_begin_index, buy_exec_index, False)
- L2LimitUpMoneyStatisticUtil.process_data(cls.random_key[code], code, 480, 519,
- buy_single_begin_index, buy_exec_index, False)
-
- @classmethod
- def test_can_buy(cls):
- code = "002923"
- load_l2_data(code, True)
- limit_up_time_manager.load_limit_up_time()
- can, msg = cls.__can_buy(code)
- print(can, msg)
if __name__ == "__main__":
# trade_manager.start_cancel_buy("000637")
# t.sleep(10)
# L2TradeDataProcessor.test()
- L2LimitUpMoneyStatisticUtil.verify_num("601958", 89178, "13:22:45")
+ # L2LimitUpMoneyStatisticUtil.verify_num("601958", 89178, "13:22:45")
# load_l2_data("600213")
#
# buy_index, buy_data = l2_data_util.get_buy_data_with_cancel_data(local_today_datas["600213"][84],
# local_today_num_operate_map.get(
# "600213"))
# print(buy_index, buy_data)
+ volume_rate = code_volumn_manager.get_volume_rate("002343")
+ print(volume_rate)
--
Gitblit v1.8.0