wehub-resource-sync
221 lines
11 KiB
Python
221 lines
11 KiB
Python
# QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
|
|
# Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
|
|
import itertools
|
|
from AlgorithmImports import *
|
|
|
|
### <summary>
|
|
### Algorithm for testing submit/update/cancel for combo orders
|
|
### </summary>
|
|
class ComboOrderTicketDemoAlgorithm(QCAlgorithm):
|
|
|
|
def initialize(self) -> None:
|
|
self.set_start_date(2015, 12, 24)
|
|
self.set_end_date(2015, 12, 24)
|
|
self.set_cash(100000)
|
|
|
|
equity = self.add_equity("GOOG", leverage=4, fill_forward=True)
|
|
option = self.add_option(equity.symbol, fill_forward=True)
|
|
self._option_symbol = option.symbol
|
|
|
|
option.set_filter(lambda u: u.standards_only().strikes(-2, +2).expiration(0, 180))
|
|
|
|
self._open_market_orders = []
|
|
self._open_leg_limit_orders = []
|
|
self._open_limit_orders = []
|
|
|
|
self._order_legs = None
|
|
|
|
def on_data(self, data: Slice) -> None:
|
|
if self._order_legs is None:
|
|
if self.is_market_open(self._option_symbol):
|
|
chain = data.option_chains.get(self._option_symbol)
|
|
if chain:
|
|
call_contracts = [contract for contract in chain if contract.right == OptionRight.CALL]
|
|
call_contracts_by_expiry = [(key, list(group)) for key, group in itertools.groupby(call_contracts, key=lambda x: x.expiry)]
|
|
call_contracts_by_expiry.sort(key=lambda x: x[0])
|
|
call_contracts = call_contracts_by_expiry[0][1]
|
|
call_contracts.sort(key=lambda x: x.strike)
|
|
|
|
if len(call_contracts) < 3:
|
|
return
|
|
|
|
quantities = [1, -2, 1]
|
|
self._order_legs = []
|
|
for i, contract in enumerate(call_contracts[:3]):
|
|
leg = Leg.create(contract.symbol, quantities[i])
|
|
self._order_legs.append(leg)
|
|
else:
|
|
# COMBO MARKET ORDERS
|
|
self.combo_market_orders()
|
|
# COMBO LIMIT ORDERS
|
|
self.combo_limit_orders()
|
|
# COMBO LEG LIMIT ORDERS
|
|
self.combo_leg_limit_orders()
|
|
|
|
def combo_market_orders(self) -> None:
|
|
if len(self._open_market_orders) != 0 or self._order_legs is None:
|
|
return
|
|
|
|
self.log("Submitting combo market orders")
|
|
|
|
tickets = self.combo_market_order(self._order_legs, 2, asynchronous=False)
|
|
self._open_market_orders.extend(tickets)
|
|
|
|
tickets = self.combo_market_order(self._order_legs, 2, asynchronous=True)
|
|
self._open_market_orders.extend(tickets)
|
|
|
|
for ticket in tickets:
|
|
response = ticket.cancel("Attempt to cancel combo market order")
|
|
if response.is_success:
|
|
raise AssertionError("Combo market orders should fill instantly, they should not be cancelable in backtest mode: " + response.order_id)
|
|
|
|
def combo_limit_orders(self) -> None:
|
|
if len(self._open_limit_orders) == 0:
|
|
self.log("Submitting ComboLimitOrder")
|
|
|
|
current_price = sum([leg.quantity * self.securities[leg.symbol].close for leg in self._order_legs])
|
|
|
|
tickets = self.combo_limit_order(self._order_legs, 2, current_price + 1.5)
|
|
self._open_limit_orders.extend(tickets)
|
|
|
|
# These won't fill, we will test cancel with this
|
|
tickets = self.combo_limit_order(self._order_legs, -2, current_price + 3)
|
|
self._open_limit_orders.extend(tickets)
|
|
else:
|
|
combo1 = self._open_limit_orders[:len(self._order_legs)]
|
|
combo2 = self._open_limit_orders[-len(self._order_legs):]
|
|
|
|
# check if either is filled and cancel the other
|
|
if self.check_group_orders_for_fills(combo1, combo2):
|
|
return
|
|
|
|
# if neither order has filled, bring in the limits by a penny
|
|
|
|
ticket = combo1[0]
|
|
new_limit = round(ticket.get(OrderField.LIMIT_PRICE) + 0.01, 2)
|
|
self.debug(f"Updating limits - Combo 1 {ticket.order_id}: {new_limit:.2f}")
|
|
fields = UpdateOrderFields()
|
|
fields.limit_price = new_limit
|
|
fields.tag = f"Update #{len(ticket.update_requests) + 1}"
|
|
ticket.update(fields)
|
|
|
|
ticket = combo2[0]
|
|
new_limit = round(ticket.get(OrderField.LIMIT_PRICE) - 0.01, 2)
|
|
self.debug(f"Updating limits - Combo 2 {ticket.order_id}: {new_limit:.2f}")
|
|
fields.limit_price = new_limit
|
|
fields.tag = f"Update #{len(ticket.update_requests) + 1}"
|
|
ticket.update(fields)
|
|
|
|
def combo_leg_limit_orders(self) -> None:
|
|
if len(self._open_leg_limit_orders) == 0:
|
|
self.log("Submitting ComboLegLimitOrder")
|
|
|
|
# submit a limit order to buy 2 shares at .1% below the bar's close
|
|
for leg in self._order_legs:
|
|
close = self.securities[leg.symbol].close
|
|
leg.order_price = close * .999
|
|
|
|
tickets = self.combo_leg_limit_order(self._order_legs, quantity=2)
|
|
self._open_leg_limit_orders.extend(tickets)
|
|
|
|
# submit another limit order to sell 2 shares at .1% above the bar's close
|
|
for leg in self._order_legs:
|
|
close = self.securities[leg.symbol].close
|
|
leg.order_price = close * 1.001
|
|
|
|
tickets = self.combo_leg_limit_order(self._order_legs, -2)
|
|
self._open_leg_limit_orders.extend(tickets)
|
|
else:
|
|
combo1 = self._open_leg_limit_orders[:len(self._order_legs)]
|
|
combo2 = self._open_leg_limit_orders[-len(self._order_legs):]
|
|
|
|
# check if either is filled and cancel the other
|
|
if self.check_group_orders_for_fills(combo1, combo2):
|
|
return
|
|
|
|
# if neither order has filled, bring in the limits by a penny
|
|
|
|
for ticket in combo1:
|
|
new_limit = round(ticket.get(OrderField.LIMIT_PRICE) + (1 if ticket.quantity > 0 else -1) * 0.01, 2)
|
|
self.debug(f"Updating limits - Combo #1: {new_limit:.2f}")
|
|
fields = UpdateOrderFields()
|
|
fields.limit_price = new_limit
|
|
fields.tag = f"Update #{len(ticket.update_requests) + 1}"
|
|
ticket.update(fields)
|
|
|
|
for ticket in combo2:
|
|
new_limit = round(ticket.get(OrderField.LIMIT_PRICE) + (1 if ticket.quantity > 0 else -1) * 0.01, 2)
|
|
self.debug(f"Updating limits - Combo #2: {new_limit:.2f}")
|
|
fields.limit_price = new_limit
|
|
fields.tag = f"Update #{len(ticket.update_requests) + 1}"
|
|
ticket.update(fields)
|
|
|
|
def on_order_event(self, order_event: OrderEvent) -> None:
|
|
order = self.transactions.get_order_by_id(order_event.order_id)
|
|
|
|
if order_event.quantity == 0:
|
|
raise AssertionError("OrderEvent quantity is Not expected to be 0, it should hold the current order Quantity")
|
|
|
|
if order_event.quantity != order.quantity:
|
|
raise AssertionError("OrderEvent quantity should hold the current order Quantity. "
|
|
f"Got {order_event.quantity}, expected {order.quantity}")
|
|
|
|
if order.type == OrderType.COMBO_LEG_LIMIT and order_event.limit_price == 0:
|
|
raise AssertionError("OrderEvent.LIMIT_PRICE is not expected to be 0 for ComboLegLimitOrder")
|
|
|
|
def check_group_orders_for_fills(self, combo1: list[OrderTicket], combo2: list[OrderTicket]) -> bool:
|
|
if all(x.status == OrderStatus.FILLED for x in combo1):
|
|
self.log(f"{combo1[0].order_type}: Canceling combo #2, combo #1 is filled.")
|
|
if any(OrderExtensions.is_open(x.status) for x in combo2):
|
|
for ticket in combo2:
|
|
ticket.cancel("Combo #1 filled.")
|
|
return True
|
|
|
|
if all(x.status == OrderStatus.FILLED for x in combo2):
|
|
self.log(f"{combo2[0].order_type}: Canceling combo #1, combo #2 is filled.")
|
|
if any(OrderExtensions.is_open(x.status) for x in combo1):
|
|
for ticket in combo1:
|
|
ticket.cancel("Combo #2 filled.")
|
|
return True
|
|
|
|
return False
|
|
|
|
def on_end_of_algorithm(self) -> None:
|
|
filled_orders = list(self.transactions.get_orders(lambda x: x.status == OrderStatus.FILLED))
|
|
order_tickets = list(self.transactions.get_order_tickets())
|
|
open_orders = self.transactions.get_open_orders()
|
|
open_order_tickets = list(self.transactions.get_open_order_tickets())
|
|
remaining_open_orders = self.transactions.get_open_orders_remaining_quantity()
|
|
|
|
# 6 market, 6 limit, 6 leg limit.
|
|
# Out of the 6 limit orders, 3 are expected to be canceled.
|
|
expected_orders_count = 18
|
|
expected_fills_count = 15
|
|
if len(filled_orders) != expected_fills_count or len(order_tickets) != expected_orders_count:
|
|
raise AssertionError(f"There were expected {expected_fills_count} filled orders and {expected_orders_count} order tickets, but there were {len(filled_orders)} filled orders and {len(order_tickets)} order tickets")
|
|
|
|
filled_combo_market_orders = [x for x in filled_orders if x.type == OrderType.COMBO_MARKET]
|
|
filled_combo_limit_orders = [x for x in filled_orders if x.type == OrderType.COMBO_LIMIT]
|
|
filled_combo_leg_limit_orders = [x for x in filled_orders if x.type == OrderType.COMBO_LEG_LIMIT]
|
|
if len(filled_combo_market_orders) != 6 or len(filled_combo_limit_orders) != 3 or len(filled_combo_leg_limit_orders) != 6:
|
|
raise AssertionError("There were expected 6 filled market orders, 3 filled combo limit orders and 6 filled combo leg limit orders, "
|
|
f"but there were {len(filled_combo_market_orders)} filled market orders, {len(filled_combo_limit_orders)} filled "
|
|
f"combo limit orders and {len(filled_combo_leg_limit_orders)} filled combo leg limit orders")
|
|
|
|
if len(open_orders) != 0 or len(open_order_tickets) != 0:
|
|
raise AssertionError("No open orders or tickets were expected")
|
|
|
|
if remaining_open_orders != 0:
|
|
raise AssertionError("No remaining quantity to be filled from open orders was expected")
|