def _settle(self, broker_name, callback=False):
#strDbg = QA_util_random_with_topic("QA_Market._settle")
#print(">-----------------------_settle----------------------------->", strDbg)
# 向事件线程发送BROKER的SETTLE事件
# 向事件线程发送ACCOUNT的SETTLE事件
for account in self.session.values():
if account.running_environment == RUNNING_ENVIRONMENT.TZERO:
for order in account.close_positions_order:
self.event_queue.put(
QA_Task(worker=self.broker[account.broker],
engine=account.broker,
event=QA_Event(
event_type=BROKER_EVENT.RECEIVE_ORDER,
order=order,
callback=self.on_insert_order)))
if account.broker == broker_name:
self.event_queue.put(
QA_Task(worker=account,
engine=broker_name,
event=QA_Event(event_type=ACCOUNT_EVENT.SETTLE)))
self.event_queue.put(
QA_Task(worker=self.broker[broker_name],
engine=broker_name,
event=QA_Event(event_type=BROKER_EVENT.SETTLE,
broker=self.broker[broker_name],
callback=callback)))
print('===== SETTLED {} ====='.format(self.running_time))
def _renew_account(self):
for account in self.session.values():
self.submit(
QA_Task(
worker=account,
event=QA_Event(
event_type=ACCOUNT_EVENT.SETTLE)))
def upcoming_data(self, broker, data):
'''
更新市场数据
broker 为名字，
data 是市场数据
被 QABacktest 中run 方法调用 upcoming_data
'''
# main thread'
# if self.running_time is not None and self.running_time!= data.datetime[0]:
# for item in self.broker.keys():
# self._settle(item)
self.running_time = data.datetime[0]
for item in self.session.values():
# session里面是已经注册的account
self.event_queue.put(
QA_Task(
worker=item, # item 是Account 类型， 是 QA_Work类型， 处理这个 事件
event=QA_Event(
event_type=ENGINE_EVENT.UPCOMING_DATA,
# args 附加的参数
market_data=data,
broker_name=broker,
send_order=self.
insert_order, # 🛠todo insert_order = insert_order
query_data=self.query_data_no_wait,
query_order=self.query_order,
query_assets=self.query_assets,
query_trade=self.query_trade)))
def _renew_account(self):
for item in self.session.values():
self.event_queue.put(
QA_Task(
worker=item,
event=QA_Event(
event_type=ACCOUNT_EVENT.SETTLE)))
def query_order(self, broker_name, order_id):
res = self.event_queue.put(
QA_Task(worker=self.broker[broker_name],
engine=broker_name,
event=QA_Event(order_id=order_id)))
return res
def _settle(self, broker_name, callback=False):
# 向事件线程发送BROKER的SETTLE事件
# 向事件线程发送ACCOUNT的SETTLE事件
for item in self.session.values():
if item.broker is broker_name:
self.event_queue.put(
QA_Task(worker=item,
engine=broker_name,
event=QA_Event(event_type=ACCOUNT_EVENT.SETTLE)))
self.event_queue.put(
QA_Task(worker=self.broker[broker_name],
engine=broker_name,
event=QA_Event(event_type=BROKER_EVENT.SETTLE,
broker=self.broker[broker_name],
callback=callback)))
print('===== SETTLED {} ====='.format(self.running_time))
def insert_order(self, account_id, amount, amount_model, time, code, price,
order_model, towards, market_type, frequence,
broker_name):
flag = False
if order_model in [ORDER_MODEL.CLOSE, ORDER_MODEL.NEXT_OPEN]:
_price = self.query_data_no_wait(broker_name=broker_name,
frequence=frequence,
market_type=market_type,
code=code,
start=time)
if _price is not None and len(_price) > 0:
price = float(_price[0][4])
flag = True
else:
QA_util_log_info('MARKET WARING: SOMEING WRONG WITH ORDER \n ')
QA_util_log_info(
'code {} date {} price {} order_model {} amount_model {}'.
format(code, time, price, order_model, amount_model))
elif order_model is ORDER_MODEL.MARKET:
_price = self.query_data_no_wait(broker_name=broker_name,
frequence=frequence,
market_type=market_type,
code=code,
start=time)
if _price is not None and len(_price) > 0:
price = float(_price[0][1])
flag = True
else:
QA_util_log_info('MARKET WARING: SOMEING WRONG WITH ORDER \n ')
QA_util_log_info(
'code {} date {} price {} order_model {} amount_model {}'.
format(code, time, price, order_model, amount_model))
elif order_model is ORDER_MODEL.LIMIT:
# if price > self.last_query_data[0][2] or price < self.last_query_data[0][3]:
flag = True
if flag:
order = self.get_account(account_id).send_order(
amount=amount,
amount_model=amount_model,
time=time,
code=code,
price=price,
order_model=order_model,
towards=towards)
self.event_queue.put(
QA_Task(
worker=self.broker[self.get_account(account_id).broker],
engine=self.get_account(account_id).broker,
event=QA_Event(event_type=BROKER_EVENT.RECEIVE_ORDER,
order=order,
callback=self.on_insert_order)))
else:
pass
def _trade(self, event):
"内部函数"
self.event_queue.put(
QA_Task(worker=self.broker[event.broker_name],
engine=event.broker_name,
event=QA_Event(event_type=BROKER_EVENT.TRADE,
broker=self.broker[event.broker_name],
broker_name=event.broker_name,
callback=self.on_trade_event)))
def _sync_position(self):
self.submit(QA_Task(worker=self.order_handler,
engine='ORDER',
event=QA_Event(
event_type=MARKET_EVENT.QUERY_POSITION,
account_cookie=list(self.session.keys()),
broker=[
self.broker[item.broker]
for item in self.session.values()
])),
nowait=True)
def _settle(self, broker_name, callback=False):
#strDbg = QA_util_random_with_topic("QA_Market._settle")
#print(">-----------------------_settle----------------------------->", strDbg)
# 向事件线程发送BROKER的SETTLE事件
# 向事件线程发送ACCOUNT的SETTLE事件
for item in self.session.values():
if item.broker is broker_name:
self.event_queue.put(
QA_Task(worker=item,
engine=broker_name,
event=QA_Event(event_type=ACCOUNT_EVENT.SETTLE)))
self.event_queue.put(
QA_Task(worker=self.broker[broker_name],
engine=broker_name,
event=QA_Event(event_type=BROKER_EVENT.SETTLE,
broker=self.broker[broker_name],
callback=callback)))
print('===== SETTLED {} ====='.format(self.running_time))
def _sync_deals(self):
self.submit(QA_Task(
worker=self.order_handler,
engine='ORDER',
event=QA_Event(
event_type=MARKET_EVENT.QUERY_DEAL,
account_cookie=list(self.session.keys()),
broker=[
self.broker[item.broker] for item in self.session.values()
],
event_queue=self.trade_engine.kernels_dict['ORDER'].queue)),
nowait=True)
def query_data(self, broker_name, frequence, market_type, code, start, end=None):
self.event_queue.put(
QA_Task(
worker=self.broker[broker_name],
engine=broker_name,
event=QA_Event(
event_type=MARKET_EVENT.QUERY_DATA,
frequence=frequence,
market_type=market_type,
code=code,
start=start,
end=end,
callback=self.on_query_data
)
))
def upcoming_data(self, broker, data):
# main thread'
# if self.running_time is not None and self.running_time!= data.datetime[0]:
# for item in self.broker.keys():
# self._settle(item)
self.running_time = data.datetime[0]
for item in self.session.values():
# session里面是已经注册的account
self.event_queue.put(
QA_Task(worker=item,
event=QA_Event(event_type=ENGINE_EVENT.UPCOMING_DATA,
market_data=data,
broker_name=broker,
send_order=self.insert_order)))
def settle_order(self):
"""交易前置结算
1. 回测: 交易队列清空,待交易队列标记SETTLE
2. 账户每日结算
3. broker结算更新
"""
if self.if_start_orderthreading:
# print('setttle_order')
self.submit(QA_Task(worker=self.order_handler,
engine='ORDER',
event=QA_Event(event_type=BROKER_EVENT.SETTLE,
event_queue=self.trade_engine.
kernels_dict['ORDER'].queue)),
nowait=True)
def _sync_orders(self):
self.submit(
QA_Task(
worker=self.order_handler,
engine='ORDER',
event=QA_Event(
event_type=MARKET_EVENT.QUERY_ORDER,
# account_cookie=list(self.session.keys()),
# broker=[self.broker[item.broker]
# for item in self.session.values()],
# 注意: 一定要给子线程的队列@@@!!!
# 2018-08-08 yutiansut
# 这个callback实现了子线程方法的自我驱动和异步任务
event_queue=self.trade_engine.kernels_dict['ORDER'].queue)
),
nowait=True)
def run(self, event):
if event.event_type is BROKER_EVENT.RECEIVE_ORDER:
# 此时的message应该是订单类
"""
OrderHandler 收到订单
orderhandler 调控转发给broker
broker返回发单结果(成功/失败)
orderhandler.order_queue 插入一个订单
执行回调
"""
order = event.order
order = event.broker.receive_order(
QA_Event(event_type=BROKER_EVENT.TRADE, order=event.order, market_data=event.market_data))
# print(threading.current_thread().ident)
order = self.order_queue.insert_order(order)
if event.callback:
event.callback(order)
elif event.event_type is BROKER_EVENT.TRADE:
# 实盘和本地 同步执行
self._trade()
# event.event_queue.task_done()
elif event.event_type is BROKER_EVENT.SETTLE:
"""订单队列的结算:
当队列中的订单都被处理过后:
算可以结算了
"""
print('SETTLE ORDERHANDLER')
# if len(self.order_queue.untrade) > 0:
# self.if_start_orderquery = False
# event.event_type = BROKER_EVENT.TRADE
# event.event_queue.put(
# QA_Task(
# worker=self,
# engine='ORDER',
# event=event
# )
# )
if len(self.order_queue.untrade)==0:
self._trade()
else:
self._trade()
# print(self.order_queue.untrade)
self.order_queue.settle()
self.order_status = pd.DataFrame()
self.deal_status = pd.DataFrame()
try:
event.event_queue.task_done()
except:
pass
elif event.event_type is MARKET_EVENT.QUERY_ORDER:
"""query_order和query_deal 需要联动使用
query_order 得到所有的订单列表
query_deal 判断订单状态--> 运行callback函数
实盘涉及到外部订单问题:
及 订单的来源 不完全从QUANTAXIS中发出, 则QA无法记录来源 (标记为外部订单)
"""
if self.if_start_orderquery:
# if QA_util_if_tradetime(datetime.datetime.now()):
# print(event.broker)
# print(event.account_cookie)
try:
# 做一些容错处理
res = [self.monitor[account].query_orders(
account.account_cookie, '') for account in list(self.monitor.keys())]
res = pd.concat(res, axis=0) if len(
res) > 0 else None
#print(res)
except:
time.sleep(1)
self.order_status = res if res is not None else self.order_status
if len(self.order_status) > 0:
#print(self.order_status)
QA_SU_save_order(self.order_status)
# else:
# time.sleep(1)
# 这里加入随机的睡眠时间 以免被发现固定的刷新请求
# event=event
event.event_type = MARKET_EVENT.QUERY_DEAL
if event.event_queue.qsize() < 1:
time.sleep(random.randint(1, 2))
# event.event_queue.task_done()
# 非阻塞
if self.if_start_orderquery:
event.event_queue.put(
QA_Task(
worker=self,
engine='ORDER',
event=event
)
)
# time.sleep(random.randint(2,5))
# print(event.event_type)
# print(event2.event_type)
# self.run(event)
# print(self.order_status)
# print('UPDATE ORDERS')
elif event.event_type is MARKET_EVENT.QUERY_DEAL:
"""order_handler- query_deal
将order_handler订单队列中的订单---和deal中匹配起来
"""
# if len(self.order_queue.pending) > 0:
# for order in self.order_queue.pending:
# #self.query
# waiting_realorder_id = [
# order.realorder_id for order in self.order_queue.trade_list]
# result = event.broker.query_deal
# time.sleep(1)
if self.if_start_orderquery:
res = [self.monitor[account].query_orders(
account.account_cookie, 'filled') for account in list(self.monitor.keys())]
try:
#res=[pd.DataFrame() if not isinstance(item,pd.DataFrame) else item for item in res]
res = pd.concat(res, axis=0) if len(
res) > 0 else pd.DataFrame()
except:
res = None
self.deal_status = res if res is not None else self.deal_status
if len(self.deal_status) > 0:
QA_SU_save_deal(self.deal_status)
# print(self.order_status)
# 检查pending订单, 更新订单状态
try:
for order in self.order_queue.pending:
if len(self.deal_status) > 0:
if order.realorder_id in self.deal_status.index.levels[1]:
# 此时有成交推送(但可能是多条)
#
res = self.deal_status.loc[order.account_cookie,
order.realorder_id]
if isinstance(res, pd.Series):
order.trade(str(res.trade_id), float(res.trade_price), int(
res.trade_amount), str(res.trade_time))
elif isinstance(res, pd.DataFrame):
if len(res) == 0:
pass
elif len(res) == 1:
res = res.iloc[0]
order.trade(str(res.trade_id), float(res.trade_price), int(
res.trade_amount), str(res.trade_time))
else:
print(res)
print(len(res))
for _, deal in res.iterrows:
order.trade(str(deal.trade_id), float(deal.trade_price), int(
deal.trade_amount), str(deal.trade_time))
except Exception as e:
print(e)
print(self.order_queue.order_list)
print(self.deal_status.index)
print(self.order_status)
# event.event_queue.task_done()
# 这里加入随机的睡眠时间 以免被发现固定的刷新请求
if event.event_queue.qsize() < 1:
time.sleep(random.randint(2, 5))
event.event_type = MARKET_EVENT.QUERY_ORDER
if self.if_start_orderquery:
event.event_queue.put(
QA_Task(
worker=self,
engine='ORDER',
event=event
)
)
# self.run(event)
# self.run(event)
elif event.event_type is MARKET_EVENT.QUERY_POSITION:
pass
def insert_order(self, account_id, amount, amount_model, time, code, price,
order_model, towards, market_type, frequence,
broker_name):
#strDbg = QA_util_random_with_topic("QA_Market.insert_order")
#print(">-----------------------insert_order----------------------------->", strDbg)
flag = False
if order_model in [ORDER_MODEL.CLOSE, ORDER_MODEL.NEXT_OPEN]:
_price = self.query_data_no_wait(broker_name=broker_name,
frequence=frequence,
market_type=market_type,
code=code,
start=time)
if _price is not None and len(_price) > 0:
price = float(_price[0][4])
flag = True
else:
QA_util_log_info('MARKET WARING: SOMEING WRONG WITH ORDER \n ')
QA_util_log_info(
'code {} date {} price {} order_model {} amount_model {}'.
format(code, time, price, order_model, amount_model))
elif order_model is ORDER_MODEL.MARKET:
_price = self.query_data_no_wait(broker_name=broker_name,
frequence=frequence,
market_type=market_type,
code=code,
start=time)
if _price is not None and len(_price) > 0:
price = float(_price[0][1])
flag = True
else:
QA_util_log_info('MARKET WARING: SOMEING WRONG WITH ORDER \n ')
QA_util_log_info(
'code {} date {} price {} order_model {} amount_model {}'.
format(code, time, price, order_model, amount_model))
elif order_model is ORDER_MODEL.LIMIT:
# if price > self.last_query_data[0][2] or price < self.last_query_data[0][3]:
flag = True
if flag:
order = self.get_account(account_id).send_order(
amount=amount,
amount_model=amount_model,
time=time,
code=code,
price=price,
order_model=order_model,
towards=towards)
# print("------------------------------------------------->")
#print("order 排队")
# print(order)
#print("时间戳" )
# print(datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')) # 日期格式化
# print("<-------------------------------------------------")
if order:
self.event_queue.put_nowait(
QA_Task(worker=self.broker[self.get_account(
account_id).broker],
engine=self.get_account(account_id).broker,
event=QA_Event(
event_type=BROKER_EVENT.RECEIVE_ORDER,
order=order,
callback=self.on_insert_order)))
else:
pass
def run(self, event):
if event.event_type is BROKER_EVENT.RECEIVE_ORDER:
# 此时的message应该是订单类
"""
OrderHandler 收到订单
orderhandler 调控转发给broker
broker返回发单结果(成功/失败)
orderhandler.order_queue 插入一个订单
执行回调
"""
order = event.order
order = event.broker.receive_order(
QA_Event(event_type=BROKER_EVENT.TRADE,
order=event.order,
market_data=event.market_data))
order = self.order_queue.insert_order(order)
if event.callback:
event.callback(order)
elif event.event_type is BROKER_EVENT.TRADE:
# 实盘和本地 同步执行
self._trade()
# event.event_queue.task_done()
elif event.event_type is BROKER_EVENT.SETTLE:
"""订单队列的结算:
当队列中的订单都被处理过后:
算可以结算了
"""
print('SETTLE ORDERHANDLER')
self.if_start_orderquery = False
if len(self.order_queue.pending) > 0:
pass
else:
raise RuntimeWarning('ORDERHANDLER STILL HAVE UNTRADE ORDERS')
self.order_queue.settle()
self.order_status = pd.DataFrame()
self.deal_status = pd.DataFrame()
try:
event.event_queue.task_done()
except:
pass
elif event.event_type is BROKER_EVENT.NEXT_TRADEDAY:
"""下一个交易日
"""
self.if_start_orderquery = True
if self.if_start_orderquery:
event.event_queue.put(
QA_Task(worker=self, engine='ORDER', event=event))
elif event.event_type is MARKET_EVENT.QUERY_ORDER:
"""query_order和query_deal 需要联动使用
query_order 得到所有的订单列表
query_deal 判断订单状态--> 运行callback函数
实盘涉及到外部订单问题:
及 订单的来源 不完全从QUANTAXIS中发出, 则QA无法记录来源 (标记为外部订单)
"""
if self.if_start_orderquery:
try:
# 做一些容错处理
res = [
self.monitor[account].query_orders(
account.account_cookie, '')
for account in list(self.monitor.keys())
]
res = pd.concat(res, axis=0) if len(res) > 0 else None
except:
time.sleep(1)
self.order_status = res if res is not None else self.order_status
if len(self.order_status) > 0:
QA_SU_save_order(self.order_status)
# 这里加入随机的睡眠时间 以免被发现固定的刷新请求
event.event_type = MARKET_EVENT.QUERY_DEAL
if event.event_queue.qsize() < 1:
time.sleep(random.randint(1, 2))
# 非阻塞
if self.if_start_orderquery:
event.event_queue.put(
QA_Task(worker=self, engine='ORDER', event=event))
elif event.event_type is MARKET_EVENT.QUERY_DEAL:
"""order_handler- query_deal
将order_handler订单队列中的订单---和deal中匹配起来
"""
if self.if_start_orderquery:
res = [
self.monitor[account].query_orders(account.account_cookie,
'filled')
for account in list(self.monitor.keys())
]
try:
res = pd.concat(
res, axis=0) if len(res) > 0 else pd.DataFrame()
except:
res = None
self.deal_status = res if res is not None else self.deal_status
if len(self.deal_status) > 0:
QA_SU_save_deal(self.deal_status)
# 检查pending订单, 更新订单状态
try:
for order in self.order_queue.pending:
if len(self.deal_status) > 0:
if order.realorder_id in self.deal_status.index.levels[
1]:
# 此时有成交推送(但可能是多条)
res = self.deal_status.loc[order.account_cookie,
order.realorder_id]
if isinstance(res, pd.Series):
order.trade(str(res.trade_id),
float(res.trade_price),
int(res.trade_amount),
str(res.trade_time))
elif isinstance(res, pd.DataFrame):
if len(res) == 0:
pass
elif len(res) == 1:
res = res.iloc[0]
order.trade(str(res.trade_id),
float(res.trade_price),
int(res.trade_amount),
str(res.trade_time))
else:
for _, deal in res.iterrows:
order.trade(str(deal.trade_id),
float(deal.trade_price),
int(deal.trade_amount),
str(deal.trade_time))
except Exception as e:
print(e)
print(self.order_queue.order_list)
print(self.deal_status.index)
print(self.order_status)
# event.event_queue.task_done()
# 这里加入随机的睡眠时间 以免被发现固定的刷新请求
if event.event_queue.qsize() < 1:
time.sleep(random.randint(2, 5))
event.event_type = MARKET_EVENT.QUERY_ORDER
if self.if_start_orderquery:
event.event_queue.put(
QA_Task(worker=self, engine='ORDER', event=event))
elif event.event_type is MARKET_EVENT.QUERY_POSITION:
pass
def run(self, event):
if event.event_type is BROKER_EVENT.RECEIVE_ORDER:
# 此时的message应该是订单类
"""
OrderHandler 收到订单
orderhandler 调控转发给broker
broker返回发单结果(成功/失败)
orderhandler.order_queue 插入一个订单
执行回调
"""
order = event.order
# print(event.broker)
order = event.broker.receive_order(
QA_Event(event_type=BROKER_EVENT.TRADE, order=event.order))
# print(threading.current_thread().ident)
order = self.order_queue.insert_order(order)
if event.callback:
event.callback(order)
elif event.event_type is BROKER_EVENT.TRADE:
# 实盘和本地 同步执行
res = []
for order in self.order_queue.pending:
result = event.broker.query_orders(order.account_cookie,
order.realorder_id)
self.order_queue.set_status(order.order_id,
result['header']['status'])
if order.callback:
order.callback(result)
res.append(result)
event.res = res
return event
elif event.event_type is BROKER_EVENT.SETTLE:
self.order_queue.settle()
elif event.event_type is MARKET_EVENT.QUERY_ORDER:
"""query_order和query_deal 需要联动使用
query_order 得到所有的订单列表
query_deal 判断订单状态--> 运行callback函数
实盘涉及到外部订单问题:
及 订单的来源 不完全从QUANTAXIS中发出, 则QA无法记录来源 (标记为外部订单)
"""
if self.if_start_orderquery:
# if QA_util_if_tradetime(datetime.datetime.now()):
# print(event.broker)
# print(event.account_cookie)
try:
# 做一些容错处理
res = [
event.broker[i].query_orders(event.account_cookie[i],
'')
for i in range(len(event.account_cookie))
]
res = pd.concat(res, axis=0) if len(res) > 0 else None
except:
time.sleep(1)
self.order_status = res if res is not None else self.order_status
if len(self.order_status) > 0:
QA_SU_save_order(self.order_status)
# else:
# time.sleep(1)
# 这里加入随机的睡眠时间 以免被发现固定的刷新请求
# event=event
event.event_type = MARKET_EVENT.QUERY_DEAL
if event.event_queue.qsize() < 1:
time.sleep(random.randint(1, 2))
# 非阻塞
event.event_queue.put(
QA_Task(worker=self, engine='ORDER', event=event))
# time.sleep(random.randint(2,5))
# print(event.event_type)
# print(event2.event_type)
# self.run(event)
# print(self.order_status)
# print('UPDATE ORDERS')
elif event.event_type is MARKET_EVENT.QUERY_DEAL:
"""order_handler- query_deal
将order_handler订单队列中的订单---和deal中匹配起来
"""
# if len(self.order_queue.pending) > 0:
# for order in self.order_queue.pending:
# #self.query
# waiting_realorder_id = [
# order.realorder_id for order in self.order_queue.trade_list]
# result = event.broker.query_deal
# time.sleep(1)
if self.if_start_orderquery:
self.deal_status = [
event.broker[i].query_orders(event.account_cookie[i],
'filled')
for i in range(len(event.account_cookie))
]
# print(self.order_status)
self.deal_status = pd.concat(
self.deal_status,
axis=0) if len(self.deal_status) > 0 else pd.DataFrame()
if len(self.deal_status) > 0:
QA_SU_save_deal(self.deal_status)
# print(self.order_status)
# 这里加入随机的睡眠时间 以免被发现固定的刷新请求
if event.event_queue.qsize() < 1:
time.sleep(random.randint(2, 5))
event.event_type = MARKET_EVENT.QUERY_ORDER
event.event_queue.put(
QA_Task(worker=self, engine='ORDER', event=event))
# self.run(event)
# self.run(event)
elif event.event_type is MARKET_EVENT.QUERY_POSITION:
pass
def insert_order(self,
account_cookie,
amount,
amount_model,
time,
code,
price,
order_model,
towards,
market_type,
frequence,
broker_name,
money=None):
#strDbg = QA_util_random_with_topic("QA_Market.insert_order")
#print(">-----------------------insert_order----------------------------->", strDbg)
flag = False
#行情切片 bar/tick/realtime
price_slice = self.query_data_no_wait(broker_name=broker_name,
frequence=frequence,
market_type=market_type,
code=code,
start=time)
price_slice = price_slice if price_slice is None else price_slice[0]
if order_model in [ORDER_MODEL.CLOSE, ORDER_MODEL.NEXT_OPEN]:
if isinstance(price_slice, np.ndarray):
if (price_slice != np.array(None)).any():
price = float(price_slice[4])
flag = True
else:
QA_util_log_info(
'MARKET WARING: SOMEING WRONG WITH ORDER \n ')
QA_util_log_info(
'code {} date {} price {} order_model {} amount_model {}'
.format(code, time, price, order_model, amount_model))
elif isinstance(price_slice, dict):
if price_slice is not None:
price = float(price_slice['close'])
flag = True
else:
QA_util_log_info(
'MARKET WARING: SOMEING WRONG WITH ORDER \n ')
QA_util_log_info(
'code {} date {} price {} order_model {} amount_model {}'
.format(code, time, price, order_model, amount_model))
elif isinstance(price_slice, list):
if price_slice is not None:
price = float(price_slice[4])
flag = True
else:
QA_util_log_info(
'MARKET WARING: SOMEING WRONG WITH ORDER \n ')
QA_util_log_info(
'code {} date {} price {} order_model {} amount_model {}'
.format(code, time, price, order_model, amount_model))
elif order_model is ORDER_MODEL.MARKET:
if isinstance(price_slice, np.ndarray):
if (price_slice != np.array(None)).any():
price = float(price_slice[1])
flag = True
else:
QA_util_log_info(
'MARKET WARING: SOMEING WRONG WITH ORDER \n ')
QA_util_log_info(
'code {} date {} price {} order_model {} amount_model {}'
.format(code, time, price, order_model, amount_model))
elif isinstance(price_slice, dict):
if price_slice is not None:
price = float(price_slice['open'])
flag = True
else:
QA_util_log_info(
'MARKET WARING: SOMEING WRONG WITH ORDER \n ')
QA_util_log_info(
'code {} date {} price {} order_model {} amount_model {}'
.format(code, time, price, order_model, amount_model))
elif order_model is ORDER_MODEL.LIMIT:
flag = True
if flag:
order = self.get_account(account_cookie).send_order(
amount=amount,
amount_model=amount_model,
time=time,
code=code,
price=price,
order_model=order_model,
towards=towards,
money=money)
if order:
# print(order)
self.submit(QA_Task(worker=self.order_handler,
engine='ORDER',
event=QA_Event(
broker=self.broker[self.get_account(
account_cookie).broker],
event_type=BROKER_EVENT.RECEIVE_ORDER,
order=order,
market_data=price_slice,
callback=self.on_insert_order)),
nowait=True)
else:
pass
