# 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.from AlgorithmImports import *### <summary>### In this algorithm we submit/update/cancel each order type### </summary>### <meta name="tag" content="trading and orders" />### <meta name="tag" content="placing orders" />### <meta name="tag" content="managing orders" />### <meta name="tag" content="order tickets" />### <meta name="tag" content="updating orders" />class OrderTicketDemoAlgorithm(QCAlgorithm):'''In this algorithm we submit/update/cancel each order type'''def initialize(self):'''Initialise the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must initialized.'''self.set_start_date(2013,10,7) #Set Start Dateself.set_end_date(2013,10,11) #Set End Dateself.set_cash(100000) #Set Strategy Cash# Find more symbols here: http://quantconnect.com/dataequity = self.add_equity("SPY")self.spy = equity.symbolself.__open_market_on_open_orders = []self.__open_market_on_close_orders = []self.__open_limit_orders = []self.__open_stop_market_orders = []self.__open_stop_limit_orders = []self.__open_trailing_stop_orders = []def on_data(self, data):'''OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here.'''# MARKET ORDERSself.market_orders()# LIMIT ORDERSself.limit_orders()# STOP MARKET ORDERSself.stop_market_orders()# STOP LIMIT ORDERSself.stop_limit_orders()# TRAILING STOP ORDERSself.trailing_stop_orders()# MARKET ON OPEN ORDERSself.market_on_open_orders()# MARKET ON CLOSE ORDERSself.market_on_close_orders()def market_orders(self):''' MarketOrders are the only orders that are processed synchronously by default, sothey'll fill by the next line of code. This behavior equally applies to live mode.You can opt out of this behavior by specifying the 'asynchronous' parameter as True.'''if self.time_is(7, 9, 31):self.log("Submitting MarketOrder")# submit a market order to buy 10 shares, this function returns an OrderTicket object# we submit the order with asynchronous = False, so it block until it is fillednew_ticket = self.market_order(self.spy, 10, asynchronous = False)if new_ticket.status != OrderStatus.FILLED:self.log("Synchronous market order was not filled synchronously!")self.quit()# we can also submit the ticket asynchronously. In a backtest, we'll still perform the fill# before the next time events for your algorithm. here we'll submit the order asynchronously# and try to cancel it, sometimes it will, sometimes it will be filled first.new_ticket = self.market_order(self.spy, 10, asynchronous = True)response = new_ticket.cancel("Attempt to cancel async order")if response.is_success:self.log("Successfully canceled async market order: {0}".format(new_ticket.order_id))else:self.log("Unable to cancel async market order: {0}".format(response.error_code))def limit_orders(self):'''LimitOrders are always processed asynchronously. Limit orders are used toset 'good' entry points for an order. For example, you may wish to golong a stock, but want a good price, so can place a LimitOrder to buy witha limit price below the current market price. Likewise the opposite is Truewhen selling, you can place a LimitOrder to sell with a limit price above thecurrent market price to get a better sale price.You can submit requests to update or cancel the LimitOrder at any time.The 'LimitPrice' for an order can be retrieved from the ticket using theOrderTicket.get(OrderField) method, for example:Code:current_limit_price = order_ticket.get(OrderField.LIMIT_PRICE)'''if self.time_is(7, 12, 0):self.log("Submitting LimitOrder")# submit a limit order to buy 10 shares at .1% below the bar's closeclose = self.securities[self.spy.value].closenew_ticket = self.limit_order(self.spy, 10, close * .999)self.__open_limit_orders.append(new_ticket)# submit another limit order to sell 10 shares at .1% above the bar's closenew_ticket = self.limit_order(self.spy, -10, close * 1.001)self.__open_limit_orders.append(new_ticket)# when we submitted new limit orders we placed them into this list,# so while there's two entries they're still open and need processingif len(self.__open_limit_orders) == 2:open_orders = self.__open_limit_orders# check if either is filled and cancel the otherlong_order = open_orders[0]short_order = open_orders[1]if self.check_pair_orders_for_fills(long_order, short_order):self.__open_limit_orders = []return# if neither order has filled, bring in the limits by a pennynew_long_limit = long_order.get(OrderField.LIMIT_PRICE) + 0.01new_short_limit = short_order.get(OrderField.LIMIT_PRICE) - 0.01self.log("Updating limits - Long: {0:.2f} Short: {1:.2f}".format(new_long_limit, new_short_limit))update_order_fields = UpdateOrderFields()update_order_fields.limit_price = new_long_limitupdate_order_fields.tag = "Update #{0}".format(len(long_order.update_requests) + 1)long_order.update(update_order_fields)update_order_fields = UpdateOrderFields()update_order_fields.limit_price = new_short_limitupdate_order_fields.tag = "Update #{0}".format(len(short_order.update_requests) + 1)short_order.update(update_order_fields)def stop_market_orders(self):'''StopMarketOrders work in the opposite way that limit orders do.When placing a long trade, the stop price must be above currentmarket price. In this way it's a 'stop loss' for a short trade.When placing a short trade, the stop price must be below currentmarket price. In this way it's a 'stop loss' for a long trade.You can submit requests to update or cancel the StopMarketOrder at any time.The 'StopPrice' for an order can be retrieved from the ticket using theOrderTicket.get(OrderField) method, for example:Code:current_stop_price = order_ticket.get(OrderField.STOP_PRICE)'''if self.time_is(7, 12 + 4, 0):self.log("Submitting StopMarketOrder")# a long stop is triggered when the price rises above the value# so we'll set a long stop .25% above the current bar's closeclose = self.securities[self.spy.value].closenew_ticket = self.stop_market_order(self.spy, 10, close * 1.0025)self.__open_stop_market_orders.append(new_ticket)# a short stop is triggered when the price falls below the value# so we'll set a short stop .25% below the current bar's closenew_ticket = self.stop_market_order(self.spy, -10, close * .9975)self.__open_stop_market_orders.append(new_ticket)# when we submitted new stop market orders we placed them into this list,# so while there's two entries they're still open and need processingif len(self.__open_stop_market_orders) == 2:# check if either is filled and cancel the otherlong_order = self.__open_stop_market_orders[0]short_order = self.__open_stop_market_orders[1]if self.check_pair_orders_for_fills(long_order, short_order):self.__open_stop_market_orders = []return# if neither order has filled, bring in the stops by a pennynew_long_stop = long_order.get(OrderField.STOP_PRICE) - 0.01new_short_stop = short_order.get(OrderField.STOP_PRICE) + 0.01self.log("Updating stops - Long: {0:.2f} Short: {1:.2f}".format(new_long_stop, new_short_stop))update_order_fields = UpdateOrderFields()update_order_fields.stop_price = new_long_stopupdate_order_fields.tag = "Update #{0}".format(len(long_order.update_requests) + 1)long_order.update(update_order_fields)update_order_fields = UpdateOrderFields()update_order_fields.stop_price = new_short_stopupdate_order_fields.tag = "Update #{0}".format(len(short_order.update_requests) + 1)short_order.update(update_order_fields)self.log("Updated price - Long: {0} Short: {1}".format(long_order.get(OrderField.STOP_PRICE), short_order.get(OrderField.STOP_PRICE)))def stop_limit_orders(self):'''StopLimitOrders work as a combined stop and limit order. First, theprice must pass the stop price in the same way a StopMarketOrder works,but then we're also guaranteed a fill price at least as good as thelimit price. This order type can be beneficial in gap down scenarioswhere a StopMarketOrder would have triggered and given the not as beneficialgapped down price, whereas the StopLimitOrder could protect you fromgetting the gapped down price through prudent placement of the limit price.You can submit requests to update or cancel the StopLimitOrder at any time.The 'StopPrice' or 'LimitPrice' for an order can be retrieved from the ticketusing the OrderTicket.get(OrderField) method, for example:Code:current_stop_price = order_ticket.get(OrderField.STOP_PRICE)current_limit_price = order_ticket.get(OrderField.LIMIT_PRICE)'''if self.time_is(8, 12, 1):self.log("Submitting StopLimitOrder")# a long stop is triggered when the price rises above the# value so we'll set a long stop .25% above the current bar's# close now we'll also be setting a limit, this means we are# guaranteed to get at least the limit price for our fills,# so make the limit price a little higher than the stop priceclose = self.securities[self.spy.value].closenew_ticket = self.stop_limit_order(self.spy, 10, close * 1.001, close - 0.03)self.__open_stop_limit_orders.append(new_ticket)# a short stop is triggered when the price falls below the# value so we'll set a short stop .25% below the current bar's# close now we'll also be setting a limit, this means we are# guaranteed to get at least the limit price for our fills,# so make the limit price a little softer than the stop pricenew_ticket = self.stop_limit_order(self.spy, -10, close * .999, close + 0.03)self.__open_stop_limit_orders.append(new_ticket)# when we submitted new stop limit orders we placed them into this list,# so while there's two entries they're still open and need processingif len(self.__open_stop_limit_orders) == 2:long_order = self.__open_stop_limit_orders[0]short_order = self.__open_stop_limit_orders[1]if self.check_pair_orders_for_fills(long_order, short_order):self.__open_stop_limit_orders = []return# if neither order has filled, bring in the stops/limits in by a pennynew_long_stop = long_order.get(OrderField.STOP_PRICE) - 0.01new_long_limit = long_order.get(OrderField.LIMIT_PRICE) + 0.01new_short_stop = short_order.get(OrderField.STOP_PRICE) + 0.01new_short_limit = short_order.get(OrderField.LIMIT_PRICE) - 0.01self.log("Updating stops - Long: {0:.2f} Short: {1:.2f}".format(new_long_stop, new_short_stop))self.log("Updating limits - Long: {0:.2f} Short: {1:.2f}".format(new_long_limit, new_short_limit))update_order_fields = UpdateOrderFields()update_order_fields.stop_price = new_long_stopupdate_order_fields.limit_price = new_long_limitupdate_order_fields.tag = "Update #{0}".format(len(long_order.update_requests) + 1)long_order.update(update_order_fields)update_order_fields = UpdateOrderFields()update_order_fields.stop_price = new_short_stopupdate_order_fields.limit_price = new_short_limitupdate_order_fields.tag = "Update #{0}".format(len(short_order.update_requests) + 1)short_order.update(update_order_fields)def trailing_stop_orders(self):'''TrailingStopOrders work the same way as StopMarketOrders, excepttheir stop price is adjusted to a certain amount, keeping it a certainfixed distance from/to the market price, depending on the order direction,which allows to preserve profits and protecting against losses.The stop price can be accessed just as with StopMarketOrders, andthe trailing amount can be accessed with the OrderTicket.get(OrderField), for example:Code:current_trailing_amount = order_ticket.get(OrderField.STOP_PRICE)trailing_as_percentage = order_ticket.get[bool](OrderField.TRAILING_AS_PERCENTAGE)'''if self.time_is(7, 12, 0):self.log("Submitting TrailingStopOrder")# a long stop is triggered when the price rises above the# value so we'll set a long stop .25% above the current bar'sclose = self.securities[self.spy.value].closestop_price = close * 1.0025new_ticket = self.trailing_stop_order(self.spy, 10, stop_price, trailing_amount=0.0025, trailing_as_percentage=True)self.__open_trailing_stop_orders.append(new_ticket)# a short stop is triggered when the price falls below the# value so we'll set a short stop .25% below the current bar'sstop_price = close * .9975new_ticket = self.trailing_stop_order(self.spy, -10, stop_price, trailing_amount=0.0025, trailing_as_percentage=True)self.__open_trailing_stop_orders.append(new_ticket)# when we submitted new stop market orders we placed them into this list,# so while there's two entries they're still open and need processingelif len(self.__open_trailing_stop_orders) == 2:long_order = self.__open_trailing_stop_orders[0]short_order = self.__open_trailing_stop_orders[1]if self.check_pair_orders_for_fills(long_order, short_order):self.__open_trailing_stop_orders = []return# if neither order has filled in the last 5 minutes, bring in the trailing percentage by 0.01%if ((self.utc_time - long_order.time).total_seconds() / 60) % 5 != 0:returnlong_trailing_percentage = long_order.get(OrderField.TRAILING_AMOUNT)new_long_trailing_percentage = max(long_trailing_percentage - 0.0001, 0.0001)short_trailing_percentage = short_order.get(OrderField.TRAILING_AMOUNT)new_short_trailing_percentage = max(short_trailing_percentage - 0.0001, 0.0001)self.log("Updating trailing percentages - Long: {0:.3f} Short: {1:.3f}".format(new_long_trailing_percentage, new_short_trailing_percentage))update_order_fields = UpdateOrderFields()# we could change the quantity, but need to specify it#Quantity =update_order_fields.trailing_amount = new_long_trailing_percentageupdate_order_fields.tag = "Update #{0}".format(len(long_order.update_requests) + 1)long_order.update(update_order_fields)update_order_fields = UpdateOrderFields()update_order_fields.trailing_amount = new_short_trailing_percentageupdate_order_fields.tag = "Update #{0}".format(len(short_order.update_requests) + 1)short_order.update(update_order_fields)def market_on_close_orders(self):'''MarketOnCloseOrders are always executed at the next market's closing price.The only properties that can be updated are the quantity and order tag properties.'''if self.time_is(9, 12, 0):self.log("Submitting MarketOnCloseOrder")# open a new position or triple our existing positionqty = self.portfolio[self.spy.value].quantityqty = 100 if qty == 0 else 2*qtynew_ticket = self.market_on_close_order(self.spy, qty)self.__open_market_on_close_orders.append(new_ticket)if len(self.__open_market_on_close_orders) == 1 and self.time.minute == 59:ticket = self.__open_market_on_close_orders[0]# check for fillsif ticket.status == OrderStatus.FILLED:self.__open_market_on_close_orders = []returnquantity = ticket.quantity + 1self.log("Updating quantity - New Quantity: {0}".format(quantity))# we can update the quantity and tagupdate_order_fields = UpdateOrderFields()update_order_fields.quantity = quantityupdate_order_fields.tag = "Update #{0}".format(len(ticket.update_requests) + 1)ticket.update(update_order_fields)if self.time_is(self.end_date.day, 12 + 3, 45):self.log("Submitting MarketOnCloseOrder to liquidate end of algorithm")self.market_on_close_order(self.spy, -self.portfolio[self.spy.value].quantity, tag="Liquidate end of algorithm")def market_on_open_orders(self):'''MarketOnOpenOrders are always executed at the nextmarket's opening price. The only properties that canbe updated are the quantity and order tag properties.'''if self.time_is(8, 14 + 2, 0):self.log("Submitting MarketOnOpenOrder")# its EOD, let's submit a market on open order to short even more!new_ticket = self.market_on_open_order(self.spy, 50)self.__open_market_on_open_orders.append(new_ticket)if len(self.__open_market_on_open_orders) == 1 and self.time.minute == 59:ticket = self.__open_market_on_open_orders[0]# check for fillsif ticket.status == OrderStatus.FILLED:self.__open_market_on_open_orders = []returnquantity = ticket.quantity + 1self.log("Updating quantity - New Quantity: {0}".format(quantity))# we can update the quantity and tagupdate_order_fields = UpdateOrderFields()update_order_fields.quantity = quantityupdate_order_fields.tag = "Update #{0}".format(len(ticket.update_requests) + 1)ticket.update(update_order_fields)def on_order_event(self, order_event):order = self.transactions.get_order_by_id(order_event.order_id)self.log("{0}: {1}: {2}".format(self.time, order.type, order_event))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")if (type(order) is LimitOrder and order_event.limit_price == 0 ortype(order) is StopLimitOrder and order_event.limit_price == 0):raise AssertionError("OrderEvent LimitPrice is Not expected to be 0 for LimitOrder and StopLimitOrder")if type(order) is StopMarketOrder and order_event.stop_price == 0:raise AssertionError("OrderEvent StopPrice is Not expected to be 0 for StopMarketOrder")# We can access the order ticket from the order eventif order_event.ticket is None:raise AssertionError("OrderEvent Ticket was not set")if order_event.order_id != order_event.ticket.order_id:raise AssertionError("OrderEvent.ORDER_ID and order_event.ticket.order_id do not match")def check_pair_orders_for_fills(self, long_order, short_order):if long_order.status == OrderStatus.FILLED:self.log("{0}: Cancelling short order, long order is filled.".format(short_order.order_type))short_order.cancel("Long filled.")return Trueif short_order.status == OrderStatus.FILLED:self.log("{0}: Cancelling long order, short order is filled.".format(long_order.order_type))long_order.cancel("Short filled")return Truereturn Falsedef time_is(self, day, hour, minute):return self.time.day == day and self.time.hour == hour and self.time.minute == minutedef on_end_of_algorithm(self):basic_order_ticket_filter = lambda x: x.symbol == self.spyfilled_orders = self.transactions.get_orders(lambda x: x.status == OrderStatus.FILLED)order_tickets = self.transactions.get_order_tickets(basic_order_ticket_filter)open_orders = self.transactions.get_open_orders(lambda x: x.symbol == self.spy)open_order_tickets = self.transactions.get_open_order_tickets(basic_order_ticket_filter)remaining_open_orders = self.transactions.get_open_orders_remaining_quantity(basic_order_ticket_filter)# The type returned by self.transactions.get_orders() is iterable and not a list# that's why we use sum() to get the size of the iterable object typefilled_orders_size = sum(1 for order in filled_orders)order_tickets_size = sum(1 for ticket in order_tickets)open_order_tickets_size = sum(1 for ticket in open_order_tickets)assert(filled_orders_size == 9 and order_tickets_size == 12), "There were expected 9 filled orders and 12 order tickets"assert(not (len(open_orders) or open_order_tickets_size)), "No open orders or tickets were expected"assert(not remaining_open_orders), "No remaining quantity to be filled from open orders was expected"spy_open_orders = self.transactions.get_open_orders(self.spy)spy_open_order_tickets = self.transactions.get_open_order_tickets(self.spy)spy_open_order_tickets_size = sum(1 for tickets in spy_open_order_tickets)spy_open_orders_remaining_quantity = self.transactions.get_open_orders_remaining_quantity(self.spy)assert(not (len(spy_open_orders) or spy_open_order_tickets_size)), "No open orders or tickets were expected"assert(not spy_open_orders_remaining_quantity), "No remaining quantity to be filled from open orders was expected"default_orders = self.transactions.get_orders()default_order_tickets = self.transactions.get_order_tickets()default_open_orders = self.transactions.get_open_orders()default_open_order_tickets = self.transactions.get_open_order_tickets()default_open_orders_remaining = self.transactions.get_open_orders_remaining_quantity()default_orders_size = sum(1 for order in default_orders)default_order_tickets_size = sum(1 for ticket in default_order_tickets)default_open_order_tickets_size = sum(1 for ticket in default_open_order_tickets)assert(default_orders_size == 12 and default_order_tickets_size == 12), "There were expected 12 orders and 12 order tickets"assert(not (len(default_open_orders) or default_open_order_tickets_size)), "No open orders or tickets were expected"assert(not default_open_orders_remaining), "No remaining quantity to be filled from open orders was expected"
此处可能存在不合适展示的内容,页面不予展示。您可通过相关编辑功能自查并修改。
如您确认内容无涉及 不当用语 / 纯广告导流 / 暴力 / 低俗色情 / 侵权 / 盗版 / 虚假 / 无价值内容或违法国家有关法律法规的内容,可点击提交进行申诉,我们将尽快为您处理。