def test_order_trade_task():
from jaqs.data.basic import TradeStat, Trade, Task, TaskInd, Order, OrderStatusInd
order = Order()
order.symbol = 'SPY'
order.task_id = 10000001
order.entrust_no = '123'
order.entrust_size = 10
order.entrust_action = 'Short'
order.entrust_price = 1.2
order.entrust_time = 95055
order.entrust_date = 20171201
order.fill_price = 1.19
order.fill_size = 3
order.commission = 0.001
str(order)
o2 = Order(order)
o2.entrust_no = '124'
o3 = Order.new_order('SPY', 'Buy', 10, 10, 20111111, 143029, 'Limit')
oind = OrderStatusInd(order)
OrderStatusInd.create_from_dict({'symbol': 'SPY'})
str(oind)
task = Task(order.task_id, 'vwap', {'a': 'b'}, order, 'place_order',
order.entrust_date)
assert (not task.is_finished)
task.task_status = common.TASK_STATUS.DONE
assert task.is_finished
tind = TaskInd(task.task_id, task.task_status, task.algo, 'success')
str(tind)
tind2 = TaskInd.create_from_dict({'task_id': 2011223})
trade = Trade(order)
trade.set_fill_info(15, 20, 20171202, 112311, 12345)
str(trade)
t2 = Trade.create_from_dict({'symbol': 'SPY'})
tstat = TradeStat()
str(tstat)
def place_order(self,
symbol,
action,
price,
size,
algo="",
algo_param={},
userdata=""):
# Generate Task
order = Order.new_order(symbol,
action,
price,
size,
self.ctx.trade_date,
self.ctx.time,
order_type=common.ORDER_TYPE.LIMIT)
task_id, msg = super(RealTimeTradeApi,
self).place_order(symbol, action, price, size,
algo, algo_param, userdata)
if self._is_failed_task(task_id):
return task_id, msg
task = Task(task_id,
algo=algo,
algo_param=algo_param,
data=order,
function_name='place_order')
self.ctx.pm.add_task(task)
return task_id, msg
def place_order(self, security, action, price, size, algo="", algo_param={}, userdata=""):
if size <= 0:
print("Invalid size {}".format(size))
return
# Generate Task
order = Order.new_order(security, action, price, size, self.ctx.trade_date, self.ctx.time,
order_type=common.ORDER_TYPE.LIMIT)
task_id = self._get_next_task_id()
order.task_id = task_id
task = Task(task_id,
algo=algo, algo_param=algo_param, data=order,
function_name='place_order', trade_date=self.ctx.trade_date)
# task.task_no = task_id
# Send Order to Exchange
entrust_no = self._simulator.add_order(order)
task.data.entrust_no = entrust_no
self.ctx.pm.add_task(task)
self.entrust_no_task_id_map[entrust_no] = task.task_id
order_status_ind = OrderStatusInd(order)
order_status_ind.order_status = common.ORDER_STATUS.ACCEPTED
self._order_status_callback(order_status_ind)
return task_id, ""
def place_order(self,
symbol,
action,
price,
size,
algo="",
algo_param=None,
userdata=""):
if algo_param is None:
algo_param = dict()
# this order object is not for TradeApi, but for strategy itself to remember the order
order = Order.new_order(symbol, action, price, size,
self.ctx.trade_date, 0)
order.entrust_no = self._get_next_num('entrust_no')
task = Task(self._get_next_task_no(),
algo=algo,
algo_param=algo_param,
data=order,
function_name="place_order")
self.ctx.pm.add_task(task)
# self.task_id_map[order.task_id].append(order.entrust_no)
# self.pm.add_order(order)
e = Event(EVENT_TYPE.PLACE_ORDER)
e.dic['task'] = task
self.publish_event(e)
def test_order_trade_task():
from jaqs.data.basic import TradeStat, Trade, Task, TaskInd, Order, OrderStatusInd
order = Order()
order.symbol = 'SPY'
order.task_id = 10000001
order.entrust_no = '123'
order.entrust_size = 10
order.entrust_action = 'Short'
order.entrust_price = 1.2
order.entrust_time = 95055
order.entrust_date = 20171201
order.fill_price = 1.19
order.fill_size = 3
order.commission = 0.001
str(order)
o2 = Order(order)
o2.entrust_no = '124'
o3 = Order.new_order('SPY', 'Buy', 10, 10, 20111111, 143029, 'Limit')
oind = OrderStatusInd(order)
OrderStatusInd.create_from_dict({'symbol': 'SPY'})
str(oind)
task = Task(order.task_id, 'vwap', {'a': 'b'}, order, 'place_order', order.entrust_date)
assert (not task.is_finished)
task.task_status = common.TASK_STATUS.DONE
assert task.is_finished
tind = TaskInd(task.task_id, task.task_status, task.algo, 'success')
str(tind)
tind2 = TaskInd.create_from_dict({'task_id': 2011223})
trade = Trade(order)
trade.set_fill_info(15, 20, 20171202, 112311, 12345)
str(trade)
t2 = Trade.create_from_dict({'symbol': 'SPY'})
tstat = TradeStat()
str(tstat)
def place_order(self,
security,
action,
price,
size,
algo="",
algo_param={},
userdata=""):
if size <= 0:
print("Invalid size {}".format(size))
return
# Generate Order
if algo == 'vwap':
order_type = common.ORDER_TYPE.VWAP
else:
order_type = common.ORDER_TYPE.LIMIT
order = Order.new_order(security,
action,
price,
size,
self.ctx.trade_date,
self.ctx.time,
order_type=order_type)
# Generate Task
task_id = self._get_next_task_id()
order.task_id = task_id
task = Task(task_id,
algo=algo,
algo_param=algo_param,
data=order,
function_name='place_order',
trade_date=self.ctx.trade_date)
# task.task_no = task_id
# Send Order to Exchange
entrust_no = self._orderbook.add_order(order)
task.data.entrust_no = entrust_no
self.ctx.pm.add_task(task)
self.entrust_no_task_id_map[entrust_no] = task.task_id
order_status_ind = OrderStatusInd(order)
order_status_ind.order_status = common.ORDER_STATUS.ACCEPTED
# order_status_ind.task_no = task_id
self._order_status_callback(order_status_ind)
'''
# TODO: not necessary
rsp = OrderRsp(entrust_no=entrust_no, task_id=task_id, msg="")
self.ctx.instance.strategy.on_order_rsp(rsp)
'''
return task_id, ""
def goal_portfolio(self, positions, algo="", algo_param={}, userdata=""):
# Generate Orders
task_id = self._get_next_task_id()
orders = {}
for goal in positions:
sec, goal_size = goal['symbol'], goal['size']
if sec in self.ctx.pm.holding_securities:
current_size = self.ctx.pm.get_position(sec).current_size
else:
current_size = 0
diff_size = goal_size - current_size
if diff_size != 0:
action = common.ORDER_ACTION.BUY if diff_size > 0 else common.ORDER_ACTION.SELL
order = FixedPriceTypeOrder.new_order(sec, action, 0.0,
abs(diff_size),
self.ctx.trade_date, 0)
if algo == 'vwap':
order.price_target = 'vwap' # TODO
elif algo.startswith('limit:'):
order.price_target = algo.split(':')[1].strip()
elif algo == '':
order.price_target = 'vwap'
else:
raise NotImplementedError(
"goal_portfolio algo = {}".format(algo))
order.task_id = task_id
order.entrust_no = self._simulator.add_order(order)
orders[order.entrust_no] = order
# Generate Task
task = Task(task_id,
algo=algo,
algo_param=algo_param,
data=orders,
function_name='goal_portfolio',
trade_date=self.ctx.trade_date)
self.ctx.pm.add_task(task)
# Send Orders to Exchange
for entrust_no, order in orders.items():
self.entrust_no_task_id_map[entrust_no] = task.task_id
order_status_ind = OrderStatusInd(order)
order_status_ind.order_status = common.ORDER_STATUS.ACCEPTED
self._order_status_callback(order_status_ind)
def goal_portfolio(self, positions, algo="", algo_param=None, userdata=""):
if algo_param is None:
algo_param = dict()
task = Task(self._get_next_task_no(),
data=positions,
algo=algo,
algo_param=algo_param,
function_name="goal_portfolio")
self.ctx.pm.add_task(task)
e = Event(EVENT_TYPE.GOAL_PORTFOLIO)
e.dic['task'] = task
self.publish_event(e)