From ba52d7ac92a36f413eacaa686f8535e859664ec6 Mon Sep 17 00:00:00 2001
From: Administrator <admin@example.com>
Date: 星期一, 28 八月 2023 09:45:11 +0800
Subject: [PATCH] bug修改
---
l2/l2_data_manager_new.py | 606 +++++++++++++++++++++---------------------------------
1 files changed, 237 insertions(+), 369 deletions(-)
diff --git a/l2/l2_data_manager_new.py b/l2/l2_data_manager_new.py
index fcf9098..decc883 100644
--- a/l2/l2_data_manager_new.py
+++ b/l2/l2_data_manager_new.py
@@ -5,15 +5,17 @@
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
-from db.redis_manager import RedisUtils
+from db.redis_manager_delegate import RedisUtils
from l2.huaxin import l2_huaxin_util, huaxin_delegate_postion_manager
+from log_module import async_log_util
from third_data import kpl_data_manager, block_info
+from trade.deal_big_money_manager import DealComputeProgressManager
from utils import global_util, ths_industry_util, tool
import l2_data_util
-from db import redis_manager
+from db import redis_manager_delegate as redis_manager
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
+ trade_result_manager, first_code_score_manager, current_price_process_manager, trade_data_manager, trade_huaxin
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, \
@@ -23,7 +25,7 @@
local_latest_datas
import l2.l2_data_util
from log_module.log import logger_l2_trade_buy, logger_l2_process, \
- logger_place_order_score, logger_l2_error
+ logger_place_order_score, logger_l2_error, logger_profile, logger_debug
# TODO l2鏁版嵁绠＄悊
from trade.trade_data_manager import CodeActualPriceProcessor
@@ -32,7 +34,7 @@
import dask
-from trade.trade_manager import TradeTargetCodeModeManager
+from trade.trade_manager import TradeTargetCodeModeManager, AccountAvailableMoneyManager
class L2DataManager:
@@ -206,7 +208,6 @@
class L2TradeDataProcessor:
unreal_buy_dict = {}
volume_rate_info = {}
- l2BigNumForMProcessor = L2BigNumForMProcessor()
__codeActualPriceProcessor = CodeActualPriceProcessor()
__ths_l2_trade_queue_manager = trade_queue_manager.thsl2tradequeuemanager()
__thsBuy1VolumnManager = trade_queue_manager.THSBuy1VolumnManager()
@@ -214,7 +215,27 @@
__l2PlaceOrderParamsManagerDict = {}
__last_buy_single_dict = {}
__TradeBuyQueue = transaction_progress.TradeBuyQueue()
- __latest_process_unique_keys = {}
+ __latest_process_order_unique_keys = {}
+ __latest_process_not_order_unique_keys = {}
+ # 鍒濆鍖�
+ __TradePointManager = l2_data_manager.TradePointManager()
+ __SecondCancelBigNumComputer = SecondCancelBigNumComputer()
+ __HourCancelBigNumComputer = HourCancelBigNumComputer()
+ __LCancelBigNumComputer = LCancelBigNumComputer()
+ __DCancelBigNumComputer = DCancelBigNumComputer()
+ __TradeStateManager = trade_manager.TradeStateManager()
+ __CodesTradeStateManager = trade_manager.CodesTradeStateManager()
+ __PauseBuyCodesManager = gpcode_manager.PauseBuyCodesManager()
+ __Buy1PriceManager = code_price_manager.Buy1PriceManager()
+ __AccountAvailableMoneyManager = AccountAvailableMoneyManager()
+ __TradeBuyDataManager = trade_data_manager.TradeBuyDataManager()
+ __LimitUpTimeManager = limit_up_time_manager.LimitUpTimeManager()
+ __BlackListCodeManager = l2_trade_util.BlackListCodeManager()
+ __WhiteListCodeManager = l2_trade_util.WhiteListCodeManager()
+ __WantBuyCodesManager = gpcode_manager.WantBuyCodesManager()
+ __TradeTargetCodeModeManager = TradeTargetCodeModeManager()
+ __DealComputeProgressManager = DealComputeProgressManager()
+ __TradeOrderIdManager = trade_huaxin.TradeOrderIdManager()
# 鑾峰彇浠ｇ爜璇勫垎
@classmethod
@@ -260,9 +281,9 @@
# 淇濆瓨鏁版嵁
__start_time = round(t.time() * 1000)
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)))
+ # __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)
@@ -271,8 +292,8 @@
@classmethod
def process_huaxin(cls, code, origin_datas):
print("process_huaxin", code, len(origin_datas))
- origin_start_time = round(t.time() * 1000)
datas = None
+ origin_start_time = round(t.time() * 1000)
try:
# 鍔犺浇鍘嗗彶鐨凩2鏁版嵁
is_normal = l2.l2_data_util.load_l2_data(code, load_latest=False)
@@ -280,6 +301,7 @@
print("鍘嗗彶鏁版嵁寮傚父:", code)
# 鏁版嵁涓嶆甯搁渶瑕佺姝氦鏄�
l2_trade_util.forbidden_trade(code)
+ origin_start_time = round(t.time() * 1000)
# 杞崲鏁版嵁鏍煎紡
_start_index = 0
total_datas = local_today_datas.get(code)
@@ -290,8 +312,9 @@
# 鑾峰彇涓嬪崟浣嶇疆
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)
+ cls.__DCancelBigNumComputer.set_real_order_index(code, place_order_index)
+ cls.__SecondCancelBigNumComputer.set_real_place_order_index(code, place_order_index)
+ async_log_util.info(logger_l2_process, "code:{} 鑾峰彇鍒颁笅鍗曠湡瀹炰綅缃細{}", code, place_order_index)
__start_time = round(t.time() * 1000)
if len(datas) > 0:
cls.process_add_datas(code, datas, 0, __start_time)
@@ -310,11 +333,13 @@
except Exception as e:
print("huaxin L2鏁版嵁澶勭悊寮傚父", code, str(e))
logging.exception(e)
+ logger_l2_error.exception(f"code:{code}")
logger_l2_error.exception(e)
finally:
- l2_data_log.l2_time(code, round(t.time() * 1000) - origin_start_time,
- "l2鏁版嵁澶勭悊鎬昏�楁椂",
- True)
+ # l2_data_log.l2_time(code, round(t.time() * 1000) - origin_start_time,
+ # "l2鏁版嵁澶勭悊鎬昏�楁椂",
+ # True)
+ pass
if datas:
l2.l2_data_util.save_l2_data(code, None, datas)
@@ -335,11 +360,11 @@
# 褰撳墠娑ㄥ仠浠凤紝璁剧疆娑ㄥ仠鏃堕棿
logger_l2_process.info("寮�鐩樻定鍋滐細{}", code)
# 淇濆瓨娑ㄥ仠鏃堕棿
- limit_up_time_manager.LimitUpTimeManager().save_limit_up_time(code, "09:30:00")
+ cls.__LimitUpTimeManager.save_limit_up_time(code, "09:30:00")
total_datas = local_today_datas[code]
- __start_time = l2_data_log.l2_time(code, round(t.time() * 1000) - __start_time,
- "l2鏁版嵁棰勫鐞嗘椂闂�")
+ # __start_time = l2_data_log.l2_time(code, round(t.time() * 1000) - __start_time,
+ # "l2鏁版嵁棰勫鐞嗘椂闂�")
if len(add_datas) > 0:
# 鏄惁涓洪鏉夸唬鐮�
@@ -348,11 +373,11 @@
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.LimitUpTimeManager().get_limit_up_time_cache(code)
+ limit_up_time = cls.__LimitUpTimeManager.get_limit_up_time_cache(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)
-
+ # score = first_code_score_manager.get_score(code, volume_rate, limit_up_time, True)
+ score = None
cls.__l2PlaceOrderParamsManagerDict[code] = l2_trade_factor.L2PlaceOrderParamsManager(code, is_first_code,
volume_rate,
volume_rate_index,
@@ -363,12 +388,12 @@
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鏁版嵁鍑嗗鏃堕棿")
+ # __start_time = l2_data_log.l2_time(code, round(t.time() * 1000) - __start_time,
+ # "l2鏁版嵁鍑嗗鏃堕棿")
# 鏃堕棿宸笉鑳藉お澶ф墠鑳藉鐞�
if not l2_trade_util.is_in_forbidden_trade_codes(code):
# 鍒ゆ柇鏄惁宸茬粡鎸傚崟
- state = trade_manager.CodesTradeStateManager().get_trade_state_cache(code)
+ state = cls.__CodesTradeStateManager.get_trade_state_cache(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:
@@ -393,11 +418,12 @@
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, round(t.time() * 1000) - __start_time,
- "l2鏁版嵁澶勭悊鏃堕棿")
+ async_log_util.info(logger_l2_process, "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, round(t.time() * 1000) - __start_time,
+ # "l2鏁版嵁澶勭悊鏃堕棿")
# 澶勭悊鏈寕鍗�
@classmethod
@@ -405,24 +431,21 @@
__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, round(t.time() * 1000) - __start_time,
- "鑾峰彇m鍊兼暟鎹�楁椂")
+ # if round(t.time() * 1000) - __start_time > 10:
+ # __start_time = l2_data_log.l2_time(code, round(t.time() * 1000) - __start_time,
+ # "鑾峰彇m鍊兼暟鎹�楁椂")
if True: # end_index - start_index < 10:
cls.__start_compute_buy(code, start_index, end_index, threshold_money, capture_time, is_first_code)
else:
- pass
- # lp = LineProfiler()
- # lp.enable()
- # lp_wrap = lp(cls.__start_compute_buy)
- # lp_wrap(code, start_index, end_index, threshold_money, capture_time, is_first_code)
- # output = io.StringIO()
- # lp.print_stats(stream=output)
- # lp.disable()
- # with open(
- # f"/home/logs/profile/{code}_start_compute_buy_{start_index}_{end_index}.txt",
- # 'w') as f:
- # f.write(output.getvalue())
+ # pass
+ lp = LineProfiler()
+ lp.enable()
+ lp_wrap = lp(cls.__start_compute_buy)
+ lp_wrap(code, start_index, end_index, threshold_money, capture_time, is_first_code)
+ output = io.StringIO()
+ lp.print_stats(stream=output)
+ lp.disable()
+ logger_profile.info(output.getvalue())
# 娴嬭瘯涓撶敤
@classmethod
@@ -434,138 +457,78 @@
def __process_order(cls, code, start_index, end_index, capture_time, is_first_code, new_add=True):
# 澧炲姞鎺ㄥ嚭鏈哄埗
unique_key = f"{start_index}-{end_index}"
- if cls.__latest_process_unique_keys.get(code) == unique_key:
+ if cls.__latest_process_order_unique_keys.get(code) == unique_key:
logger_l2_error.error(f"閲嶅澶勭悊鏁版嵁锛歝ode-{code} start_index-{start_index} end_index-{end_index}")
return
- cls.__latest_process_unique_keys[code] = unique_key
-
- # 璁＄畻瀹夊叏绗旀暟
- @dask.delayed
- def compute_safe_count():
- _start_time = round(t.time() * 1000)
- # 澶勭悊瀹夊叏绗旀暟
- 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, round(t.time() * 1000) - _start_time,
- "宸蹭笅鍗�-鑾峰彇涔板叆淇℃伅鑰楁椂")
- return None, ""
-
- @dask.delayed
- # m鍊煎ぇ鍗曡绠�
- def compute_m_big_num():
- _start_time = round(t.time() * 1000)
- # 璁＄畻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, round(t.time() * 1000) - _start_time,
- "宸蹭笅鍗�-m鍊煎ぇ鍗曡绠�")
- return None, ""
-
- # 涔�1鎾よ绠�
- @dask.delayed
- def buy_1_cancel():
- _start_time = round(t.time() * 1000)
- # 鎾ゅ崟璁＄畻,鍙湅涔�1
- cancel_data, cancel_msg = L2LimitUpMoneyStatisticUtil().process_data(code, start_index,
- end_index,
- buy_single_index, buy_exec_index)
-
- l2_data_log.l2_time(code, round(t.time() * 1000) - _start_time,
- "宸蹭笅鍗�-涔�1缁熻鑰楁椂")
- # 涔�1涓嶄細瑙﹀彂鎾ゅ崟
- return None, ""
- # return cancel_data, cancel_msg
+ cls.__latest_process_order_unique_keys[code] = unique_key
# S鎾�
- @dask.delayed
- def s_cancel():
+ def s_cancel(_buy_single_index, _buy_exec_index):
_start_time = round(t.time() * 1000)
# S鎾ゅ崟璁＄畻锛岀湅绉掔骇澶у崟鎾ゅ崟
try:
- b_need_cancel, b_cancel_data = SecondCancelBigNumComputer().need_cancel(code, buy_single_index,
- buy_exec_index, start_index,
- end_index, total_data,
- code_volumn_manager.get_volume_rate_index(
- buy_volume_rate),
- cls.volume_rate_info[code][1],
- is_first_code)
+ b_need_cancel, b_cancel_data = cls.__SecondCancelBigNumComputer.need_cancel(code, _buy_single_index,
+ _buy_exec_index,
+ start_index,
+ end_index, total_data,
+ 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)
+ logger_l2_error.error(f"鍙傛暟锛歜uy_single_index-{_buy_single_index} buy_exec_index-{_buy_exec_index}")
+ logger_l2_error.exception(e)
finally:
- l2_data_log.l2_time(code, round(t.time() * 1000) - _start_time,
- "宸蹭笅鍗�-s绾уぇ鍗曚及绠�")
+ # l2_data_log.l2_time(code, round(t.time() * 1000) - _start_time,
+ # "宸蹭笅鍗�-s绾уぇ鍗曚及绠�")
+ pass
return None, ""
# H鎾�
- @dask.delayed
- def h_cancel():
+ def h_cancel(_buy_single_index, _buy_exec_index):
_start_time = round(t.time() * 1000)
try:
- b_need_cancel, b_cancel_data = HourCancelBigNumComputer().need_cancel(code, buy_single_index,
- buy_exec_index, start_index,
- end_index, total_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)
+ b_need_cancel, b_cancel_data = cls.__HourCancelBigNumComputer.need_cancel(code, _buy_single_index,
+ _buy_exec_index, start_index,
+ end_index, total_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)
+ logger_l2_error.error(f"鍙傛暟锛歜uy_single_index-{_buy_single_index} buy_exec_index-{_buy_exec_index}")
+ logger_l2_error.exception(e)
finally:
- l2_data_log.l2_time(code, round(t.time() * 1000) - _start_time, "宸蹭笅鍗�-H鎾ゅぇ鍗曡绠�")
+ # l2_data_log.l2_time(code, round(t.time() * 1000) - _start_time, "宸蹭笅鍗�-H鎾ゅぇ鍗曡绠�")
+ pass
return None, ""
# L鎾�
- @dask.delayed
- def l_cancel():
+ def l_cancel(_buy_single_index, _buy_exec_index):
_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)
+ b_need_cancel, b_cancel_data = cls.__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)
+ logger_l2_error.error(f"鍙傛暟锛歜uy_single_index-{_buy_single_index} buy_exec_index-{_buy_exec_index}")
+ logger_l2_error.exception(e)
finally:
- l2_data_log.l2_time(code, round(t.time() * 1000) - _start_time, "宸蹭笅鍗�-L鎾ゅぇ鍗曡绠�")
- return None, ""
-
- # 鏉夸笂鍗栨挙
- @dask.delayed
- def sell_cancel():
- _start_time = round(t.time() * 1000)
- # 缁熻鏉夸笂鍗�
- try:
- 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, round(t.time() * 1000) - _start_time, "宸蹭笅鍗�-鏉夸笂鍗栬�楁椂")
- return None, ""
-
- # 鏄惁闇�瑕佹挙閿�
- @dask.delayed
- def is_need_cancel(*args):
- try:
- for i in range(0, len(args)):
- _cancel_data, _cancel_msg = args[i]
- if _cancel_data:
- return _cancel_data, _cancel_msg
- except Exception as e:
- logging.exception(e)
- finally:
+ # l2_data_log.l2_time(code, round(t.time() * 1000) - _start_time, "宸蹭笅鍗�-L鎾ゅぇ鍗曡绠�")
pass
return None, ""
@@ -579,48 +542,32 @@
# 鑾峰彇涔板叆淇″彿璧峰鐐�
buy_single_index, buy_exec_index, buy_compute_index, num, count, max_num_set, buy_volume_rate = cls.__get_order_begin_pos(
code)
+ # 榛樿閲忎负0.2
+ if buy_volume_rate is None:
+ buy_volume_rate = 0.2
- f1 = compute_safe_count()
- f2 = compute_m_big_num()
- f3 = s_cancel()
- f4 = h_cancel()
- f5 = buy_1_cancel()
- f6 = sell_cancel()
- 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,
- "宸蹭笅鍗�-鎾ゅ崟 鍒ゆ柇鏄惁闇�瑕佹挙鍗�")
-
+ # 渚濇澶勭悊
+ cancel_data, cancel_msg = s_cancel(buy_single_index, buy_exec_index)
+ # if not cancel_data:
+ # cancel_data, cancel_msg = h_cancel(buy_single_index, buy_exec_index)
+ if not cancel_data:
+ cancel_data, cancel_msg = l_cancel(buy_single_index, buy_exec_index)
+ # l2_log.debug(code, "鎾ゅ崟璁＄畻缁撴潫")
+ # _start_time = l2_data_log.l2_time(code, tool.get_now_timestamp() - _start_time,
+ # "宸蹭笅鍗�-鎾ゅ崟 鍒ゆ柇鏄惁闇�瑕佹挙鍗�")
if cancel_data:
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, is_first_code)
- _start_time = l2_data_log.l2_time(code, tool.get_now_timestamp() - _start_time,
- "澶勭悊鍓╀綑鏁版嵁 鑰楁椂")
- else:
- # 鎾ゅ崟灏氭湭鎴愬姛
- pass
+ 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, is_first_code)
+ # _start_time = l2_data_log.l2_time(code, tool.get_now_timestamp() - _start_time,
+ # "澶勭悊鍓╀綑鏁版嵁 鑰楁椂")
else:
- # 濡傛灉鏈夎櫄鎷熶笅鍗曢渶瑕佺湡瀹炰笅鍗�
- unreal_buy_info = cls.unreal_buy_dict.get(code)
- if unreal_buy_info is not None:
- 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], is_first_code)
- _start_time = l2_data_log.l2_time(code, tool.get_now_timestamp() - _start_time,
- "宸茶櫄鎷熶笅鍗�-鎵ц鐪熷疄涓嬪崟 澶栭儴鑰楁椂")
+ pass
@classmethod
def __buy(cls, code, capture_timestamp, last_data, last_data_index, is_first_code):
@@ -631,7 +578,7 @@
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)
+ # __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)
@@ -643,7 +590,7 @@
if need_clear_data:
trade_result_manager.real_cancel_success(code, buy_single_index, buy_exec_index,
local_today_datas.get(code))
- return
+ return False
else:
l2_log.debug(code, "鍙互涓嬪崟锛屽師鍥狅細{}", reason)
@@ -651,28 +598,31 @@
l2_log.debug(code, "寮�濮嬫墽琛屼拱鍏�")
trade_manager.start_buy(code, capture_timestamp, last_data,
last_data_index)
- ################涓嬪崟鎴愬姛澶勭悊################
- trade_result_manager.real_buy_success(code)
l2_log.debug(code, "鎵ц涔板叆鎴愬姛")
+ ################涓嬪崟鎴愬姛澶勭悊################
+ trade_result_manager.real_buy_success(code, cls.__TradePointManager)
+ 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_start_index':{} ,'buy_exec_index':{},'volume_reate':{},'desc':'{}'",
buy_single_index, buy_exec_index, cls.volume_rate_info[code][0],
- cls.__l2PlaceOrderParamsManagerDict[code].score, params_desc)
+ params_desc)
except Exception as e:
logger_l2_error.exception(e)
l2_log.debug(code, "鎵ц涔板叆寮傚父:{}", str(e))
pass
finally:
- l2_log.debug(code, "m鍊煎奖鍝嶅洜瀛愶細{}", l2_trade_factor.L2TradeFactorUtil.factors_to_string(code))
+ # l2_log.debug(code, "m鍊煎奖鍝嶅洜瀛愶細{}", l2_trade_factor.L2TradeFactorUtil.factors_to_string(code))
+ pass
+ return True
# 鏄惁鍙互鍙栨秷
@classmethod
def __can_cancel(cls, code):
if constant.TEST:
return True, ""
- if l2_trade_util.WhiteListCodeManager().is_in_cache(code):
+ if cls.__WhiteListCodeManager.is_in_cache(code):
return False, "浠ｇ爜鍦ㄧ櫧鍚嶅崟涓�"
# 鏆傛椂娉ㄩ噴鎺�
@@ -706,7 +656,7 @@
@classmethod
def __can_buy(cls, code):
__start_time = t.time()
- if not trade_manager.TradeStateManager().is_can_buy_cache():
+ if not cls.__TradeStateManager.is_can_buy_cache():
return False, True, f"浠婃棩宸茬姝氦鏄�"
# 涔嬪墠鐨勪唬鐮�
# 棣栨澘浠ｇ爜涓斿皻鏈定鍋滆繃鐨勪笉鑳戒笅鍗�
@@ -761,7 +711,7 @@
if volumn_rate >= 1.3:
return False, False, "鏈�澶ч噺姣旇秴杩�1.3涓嶈兘涔�"
- limit_up_time = limit_up_time_manager.LimitUpTimeManager().get_limit_up_time_cache(code)
+ limit_up_time = cls.__LimitUpTimeManager.get_limit_up_time_cache(code)
if limit_up_time is not None:
limit_up_time_seconds = l2.l2_data_util.L2DataUtil.get_time_as_second(
limit_up_time)
@@ -829,20 +779,21 @@
# 鍙互涓嬪崟
return True, False, None
finally:
- l2_data_log.l2_time(code, round((t.time() - __start_time) * 1000), "鏄惁鍙互涓嬪崟璁＄畻")
+ # l2_data_log.l2_time(code, round((t.time() - __start_time) * 1000), "鏄惁鍙互涓嬪崟璁＄畻")
+ pass
@classmethod
def __can_buy_first(cls, code):
- if not trade_manager.TradeStateManager().is_can_buy_cache():
+ if not cls.__TradeStateManager.is_can_buy_cache():
return False, True, f"浠婃棩宸茬姝氦鏄�"
- if gpcode_manager.PauseBuyCodesManager().is_in_cache(code):
+ if cls.__PauseBuyCodesManager.is_in_cache(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 float(limit_up_price) >= constant.MAX_CODE_PRICE:
+ return False, True, f"鑲′环澶т簬{constant.MAX_CODE_PRICE}鍧�"
if constant.L2_SOURCE_TYPE == constant.L2_SOURCE_TYPE_HUAXIN:
trade_price = current_price_process_manager.get_trade_price(code)
@@ -878,7 +829,7 @@
zyltgb = global_util.zyltgb_map.get(code)
if zyltgb >= 200 * 100000000:
- buy1_price = code_price_manager.Buy1PriceManager().get_buy1_price(code)
+ buy1_price = cls.__Buy1PriceManager.get_buy1_price(code)
if buy1_price is None:
return False, True, f"灏氭湭鑾峰彇鍒颁拱1浠�"
dif = float(limit_up_price) - float(buy1_price)
@@ -886,46 +837,46 @@
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)
+ open_limit_up_lowest_price = cls.__Buy1PriceManager.get_open_limit_up_lowest_price(code)
price_pre_close = gpcode_manager.CodePrePriceManager.get_price_pre_cache(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.LimitUpTimeManager().get_limit_up_time_cache(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)
+ # limit_up_info = cls.__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 = cls.__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 = cls.__LimitUpTimeManager.get_limit_up_time_cache(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)
+ # 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_cache(code):
- if TradeTargetCodeModeManager().get_mode_cache() == TradeTargetCodeModeManager.MODE_ONLY_BUY_WANT_CODES:
+ if not cls.__WantBuyCodesManager.is_in_cache(code):
+ if cls.__TradeTargetCodeModeManager.get_mode_cache() == 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
+ score_index = None # cls.__l2PlaceOrderParamsManagerDict[code].score_index
+ score = None # cls.__l2PlaceOrderParamsManagerDict[code].score
+ score_info = None # cls.__l2PlaceOrderParamsManagerDict[code].score_info
# lp = LineProfiler()
# lp.enable()
@@ -937,56 +888,29 @@
# with open(f"{constant.get_path_prefix()}/logs/profile/{code}_can_buy_first.txt", 'w') as f:
# f.write(output.getvalue())
# return results
- return cls.can_buy_first(code, limit_up_price, score_index, score, score_info, cls.volume_rate_info[code])
-
+ return cls.can_buy_first(code, limit_up_price)
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浜�"
+ def can_buy_first(cls, code, limit_up_price):
# 鍒ゆ柇鏉垮潡
- yesterday_codes = kpl_data_manager.get_yesterday_limit_up_codes()
- plate_can_buy, msg = CodePlateKeyBuyManager.can_buy(code,
- kpl_data_manager.KPLLimitUpDataRecordManager.latest_origin_datas,
- kpl_data_manager.KPLLimitUpDataRecordManager.total_datas,
- yesterday_codes,
- block_info.get_before_blocks_dict())
- if not plate_can_buy:
- return False, True, msg
- return True, False, msg
+ can_buy_result = CodePlateKeyBuyManager.can_buy(code)
+ if can_buy_result is None:
+ logger_debug.warning("娌℃湁鑾峰彇鍒版澘鍧楃紦瀛橈紝灏嗚幏鍙栨澘鍧�")
+ yesterday_codes = kpl_data_manager.get_yesterday_limit_up_codes()
+ CodePlateKeyBuyManager.update_can_buy_blocks(code,
+ kpl_data_manager.KPLLimitUpDataRecordManager.latest_origin_datas,
+ kpl_data_manager.KPLLimitUpDataRecordManager.total_datas,
+ yesterday_codes,
+ block_info.get_before_blocks_dict())
+ can_buy_result = CodePlateKeyBuyManager.can_buy(code)
- # 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, ""
+ if can_buy_result is None:
+ return False, True, "灏氭湭鑾峰彇鍒版澘鍧椾俊鎭�"
+ if not can_buy_result[0]:
+ return False, True, can_buy_result[1]
+ return True, False, can_buy_result[1]
@classmethod
def __cancel_buy(cls, code):
@@ -1042,11 +966,18 @@
new_add=True):
if compute_end_index < compute_start_index:
return
+
+ unique_key = f"{compute_start_index}-{compute_end_index}"
+ if cls.__latest_process_not_order_unique_keys.get(code) == unique_key:
+ logger_l2_error.error(f"閲嶅澶勭悊鏁版嵁锛歝ode-{code} start_index-{compute_start_index} end_index-{compute_end_index}")
+ return
+ cls.__latest_process_not_order_unique_keys[code] = unique_key
+
_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))
+ # 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, buy_volume_rate = cls.__get_order_begin_pos(
@@ -1073,10 +1004,8 @@
count = 0
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, tool.get_now_timestamp() - _start_time, "涓嬪崟淇″彿璁＄畻鏃堕棿")
+ # _start_time = l2_data_log.l2_time(code, tool.get_now_timestamp() - _start_time, "涓嬪崟淇″彿璁＄畻鏃堕棿")
if buy_single_index is None:
# 鏈幏鍙栧埌涔板叆淇″彿锛岀粓姝㈢▼搴�
@@ -1087,16 +1016,11 @@
if new_get_single:
start_process_index = buy_single_index
- # 璁＄畻m鍊煎ぇ鍗�
- 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, tool.get_now_timestamp() - _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)
- _start_time = l2_data_log.l2_time(code, tool.get_now_timestamp() - _start_time, "m鍊奸槇鍊艰绠�")
+ # _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,
@@ -1106,9 +1030,10 @@
threshold_money,
buy_single_index,
max_num_set)
- _start_time = l2_data_log.l2_time(code, tool.get_now_timestamp() - _start_time, "绾拱棰濈粺璁℃椂闂�")
+ # _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])
+ l2_log.debug(code, "m鍊�-{} 閲忔瘮:{} rebegin_buy_pos:{}", threshold_money, cls.volume_rate_info[code][0],
+ rebegin_buy_pos)
# 涔板叆淇″彿浣嶄笌璁＄畻浣嶇疆闂撮殧2s鍙婁互涓婁簡
if rebegin_buy_pos is not None:
@@ -1121,75 +1046,22 @@
l2_log.debug(code, "鑾峰彇鍒颁拱鍏ユ墽琛屼綅缃細{} m鍊硷細{} 绾拱鎵嬫暟锛歿} 绾拱鍗曟暟锛歿} 鏁版嵁锛歿} ,閲忔瘮:{} ", compute_index, threshold_money,
buy_nums,
buy_count, total_datas[compute_index], cls.volume_rate_info[code])
-
- 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.LimitUpTimeManager().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)
-
- # 宸茶骞惰澶勭悊
- # # 璁板綍涔板叆淇″彿浣嶇疆
- # 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)
+ 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])
+ cls.__LimitUpTimeManager.save_limit_up_time(code, total_datas[compute_index]["val"]["time"])
+ cls.__TradePointManager.delete_buy_cancel_point(code)
+ l2_log.debug(code, "delete_buy_cancel_point")
+ # 鐩存帴涓嬪崟
+ ordered = cls.__buy(code, capture_time, total_datas[compute_index], compute_index, is_first_code)
# 鏁版嵁鏄惁澶勭悊瀹屾瘯
- if compute_index >= compute_end_index:
- need_cancel, cancel_data = SecondCancelBigNumComputer().need_cancel(code, buy_single_index,
- compute_index,
- buy_single_index, compute_index,
- 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, tool.get_now_timestamp() - _start_time,
- "S绾уぇ鍗曞鐞嗚�楁椂", force=True)
- l2_log.debug(code, "鏁版嵁澶勭悊瀹屾瘯锛屼笅鍗�, 鏁版嵁鎴浘鏃堕棿-{}", capture_time)
- # 鏁版嵁宸茬粡澶勭悊瀹屾瘯锛屽鏋滆繕娌℃挙鍗曞氨瀹為檯涓嬪崟
- if need_cancel:
- if cls.cancel_buy(code, "S绾уぇ鍗曟挙閿�"):
- # 鎵ц鎾ゅ崟鎴愬姛
- pass
+ if compute_index < compute_end_index:
+ if ordered:
+ cls.__process_order(code, compute_index + 1, compute_end_index, capture_time, is_first_code, False)
else:
- 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, is_first_code,
- cls.volume_rate_info[code][1],
- cls.volume_rate_info[code][1], False)
-
- _start_time = l2_data_log.l2_time(code, tool.get_now_timestamp() - _start_time,
- "S绾уぇ鍗曞鐞嗚�楁椂", force=True)
- # 鏁版嵁灏氭湭澶勭悊瀹屾瘯锛岃繘琛屼笅涓�姝ュ鐞�
- l2_log.debug(code, "鏁版嵁灏氭湭澶勭悊瀹屾瘯锛岃繘琛屼笅涓�姝ュ鐞嗭紝澶勭悊杩涘害锛歿}", compute_index)
- # 澶勭悊鎾ゅ崟姝ラ
- 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)
-
+ cls.__start_compute_buy(code, compute_index + 1, compute_end_index, threshold_money, capture_time,
+ is_first_code)
else:
# 鏈揪鍒颁笅鍗曟潯浠讹紝淇濆瓨绾拱棰濓紝璁剧疆绾拱棰�
# 璁板綍涔板叆淇″彿浣嶇疆
@@ -1202,17 +1074,17 @@
# 鑾峰彇涓嬪崟璧峰淇″彿
@classmethod
def __get_order_begin_pos(cls, code):
- buy_single_index, buy_exec_index, compute_index, num, count, max_num_set, volume_rate = l2_data_manager.TradePointManager().get_buy_compute_start_data_cache(
+ buy_single_index, buy_exec_index, compute_index, num, count, max_num_set, volume_rate = cls.__TradePointManager.get_buy_compute_start_data_cache(
code)
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(cls, 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, volume_rate)
+ cls.__TradePointManager.set_buy_compute_start_data(code, buy_single_index, buy_exec_index, compute_index, num,
+ count,
+ max_num_set, volume_rate)
# 璁＄畻涓嬪崟璧峰淇″彿
# compute_data_count 鐢ㄤ簬璁＄畻鐨刲2鏁版嵁鏁伴噺
@@ -1283,13 +1155,9 @@
@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_set):
- def get_threshold_count():
- count = threshold_count
- return count
-
_start_time = t.time()
total_datas = local_today_datas[code]
- is_first_code = gpcode_manager.FirstCodeManager().is_in_first_record_cache(code)
+ # is_first_code = gpcode_manager.FirstCodeManager().is_in_first_record_cache(code)
buy_nums = origin_num
buy_count = origin_count
@@ -1326,7 +1194,7 @@
trigger_buy = False
# 蹇呴』涓鸿繛缁�2绉掑唴鐨勬暟鎹�
if L2DataUtil.get_time_as_second(_val["time"]) - buy_single_time_seconds + 1 > max_space_time:
- TradePointManager().delete_buy_point(code)
+ cls.__TradePointManager.delete_buy_point(code)
if i == compute_end_index:
# 鏁版嵁澶勭悊瀹屾瘯
return None, buy_nums, buy_count, None, max_buy_num_set
@@ -1344,9 +1212,9 @@
# 鍙粺璁�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(
- f"{code}鑾峰彇鍒颁拱鍏ユ墽琛岀偣锛歿i} 缁熻绾拱鎵嬫暟锛歿buy_nums} 鐩爣绾拱鎵嬫暟锛歿threshold_num} 缁熻绾拱鍗曟暟锛歿buy_count} 鐩爣绾拱鍗曟暟锛歿get_threshold_count()}, 澶у崟鏁伴噺锛歿len(max_buy_num_set)}")
+ if buy_nums >= threshold_num and buy_count >= threshold_count:
+ async_log_util.info(logger_l2_trade_buy,
+ f"{code}鑾峰彇鍒颁拱鍏ユ墽琛岀偣锛歿i} 缁熻绾拱鎵嬫暟锛歿buy_nums} 鐩爣绾拱鎵嬫暟锛歿threshold_num} 缁熻绾拱鍗曟暟锛歿buy_count} 鐩爣绾拱鍗曟暟锛歿threshold_count}, 澶у崟鏁伴噺锛歿len(max_buy_num_set)}")
elif L2DataUtil.is_limit_up_price_buy_cancel(_val):
if _val["num"] >= bigger_num:
# 鍙粺璁�59涓囦互涓婄殑閲戦
@@ -1385,13 +1253,13 @@
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 max_buy_num_set_count >= big_num_count:
+ if buy_nums >= threshold_num and buy_count >= 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
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)
+ threshold_num, buy_count, threshold_count, max_buy_num_set_count, big_num_count)
return None, buy_nums, buy_count, None, max_buy_num_set
--
Gitblit v1.8.0