-
-
Notifications
You must be signed in to change notification settings - Fork 3.1k
/
OrderTicketDemoAlgorithm.py
352 lines (285 loc) · 16.8 KB
/
OrderTicketDemoAlgorithm.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
# 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 clr import AddReference
AddReference("System")
AddReference("QuantConnect.Algorithm")
AddReference("QuantConnect.Common")
from System import *
from QuantConnect import *
from QuantConnect.Algorithm import *
from QuantConnect.Orders import *
from QuantConnect.Data 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.SetStartDate(2013,10,7) #Set Start Date
self.SetEndDate(2013,10,11) #Set End Date
self.SetCash(100000) #Set Strategy Cash
# Find more symbols here: http://quantconnect.com/data
equity = self.AddEquity("SPY")
self.spy = equity.Symbol
self.__openMarketOnOpenOrders = []
self.__openMarketOnCloseOrders = []
self.__openLimitOrders = []
self.__openStopMarketOrders = []
self.__openStopLimitOrders = []
def OnData(self, data):
'''OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here.'''
# MARKET ORDERS
self.MarketOrders()
# LIMIT ORDERS
self.LimitOrders()
# STOP MARKET ORDERS
self.StopMarketOrders()
## STOP LIMIT ORDERS
self.StopLimitOrders()
## MARKET ON OPEN ORDERS
self.MarketOnOpenOrders()
## MARKET ON CLOSE ORDERS
self.MarketOnCloseOrders()
def MarketOrders(self):
''' MarketOrders are the only orders that are processed synchronously by default, so
they'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.TimeIs(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 filled
newTicket = self.MarketOrder(self.spy, 10, asynchronous = False)
if newTicket.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.
newTicket = self.MarketOrder(self.spy, 10, asynchronous = True)
response = newTicket.Cancel("Attempt to cancel async order")
if response.IsSuccess:
self.Log("Successfully canceled async market order: {0}".format(newTicket.OrderId))
else:
self.Log("Unable to cancel async market order: {0}".format(response.ErrorCode))
def LimitOrders(self):
'''LimitOrders are always processed asynchronously. Limit orders are used to
set 'good' entry points for an order. For example, you may wish to go
long a stock, but want a good price, so can place a LimitOrder to buy with
a limit price below the current market price. Likewise the opposite is True
when selling, you can place a LimitOrder to sell with a limit price above the
current 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 the
OrderTicket.Get(OrderField) method, for example:
Code:
currentLimitPrice = orderTicket.Get(OrderField.LimitPrice)'''
if self.TimeIs(7, 12, 0):
self.Log("Submitting LimitOrder")
# submit a limit order to buy 10 shares at .1% below the bar's close
close = self.Securities[self.spy.Value].Close
newTicket = self.LimitOrder(self.spy, 10, close * .999)
self.__openLimitOrders.append(newTicket)
# submit another limit order to sell 10 shares at .1% above the bar's close
newTicket = self.LimitOrder(self.spy, -10, close * 1.001)
self.__openLimitOrders.append(newTicket)
# when we submitted new limit orders we placed them into this list,
# so while there's two entries they're still open and need processing
if len(self.__openLimitOrders) == 2:
openOrders = self.__openLimitOrders
# check if either is filled and cancel the other
longOrder = openOrders[0]
shortOrder = openOrders[1]
if self.CheckPairOrdersForFills(longOrder, shortOrder):
self.__openLimitOrders = []
return
# if niether order has filled, bring in the limits by a penny
newLongLimit = longOrder.Get(OrderField.LimitPrice) + 0.01
newShortLimit = shortOrder.Get(OrderField.LimitPrice) - 0.01
self.Log("Updating limits - Long: {0:.2f} Short: {1:.2f}".format(newLongLimit, newShortLimit))
updateOrderFields = UpdateOrderFields()
updateOrderFields.LimitPrice = newLongLimit
updateOrderFields.Tag = "Update #{0}".format(len(longOrder.UpdateRequests) + 1)
longOrder.Update(updateOrderFields)
updateOrderFields = UpdateOrderFields()
updateOrderFields.LimitPrice = newShortLimit
updateOrderFields.Tag = "Update #{0}".format(len(shortOrder.UpdateRequests) + 1)
shortOrder.Update(updateOrderFields)
def StopMarketOrders(self):
'''StopMarketOrders work in the opposite way that limit orders do.
When placing a long trade, the stop price must be above current
market price. In this way it's a 'stop loss' for a short trade.
When placing a short trade, the stop price must be below current
market 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 the
OrderTicket.Get(OrderField) method, for example:
Code:
currentStopPrice = orderTicket.Get(OrderField.StopPrice)'''
if self.TimeIs(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 close
close = self.Securities[self.spy.Value].Close
newTicket = self.StopMarketOrder(self.spy, 10, close * 1.0025)
self.__openStopMarketOrders.append(newTicket)
# 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
newTicket = self.StopMarketOrder(self.spy, -10, close * .9975)
self.__openStopMarketOrders.append(newTicket)
# 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 processing
if len(self.__openStopMarketOrders) == 2:
# check if either is filled and cancel the other
longOrder = self.__openStopMarketOrders[0]
shortOrder = self.__openStopMarketOrders[1]
if self.CheckPairOrdersForFills(longOrder, shortOrder):
self.__openStopMarketOrders = []
return
# if neither order has filled, bring in the stops by a penny
newLongStop = longOrder.Get(OrderField.StopPrice) - 0.01
newShortStop = shortOrder.Get(OrderField.StopPrice) + 0.01
self.Log("Updating stops - Long: {0:.2f} Short: {1:.2f}".format(newLongStop, newShortStop))
updateOrderFields = UpdateOrderFields()
updateOrderFields.StopPrice = newLongStop
updateOrderFields.Tag = "Update #{0}".format(len(longOrder.UpdateRequests) + 1)
longOrder.Update(updateOrderFields)
updateOrderFields = UpdateOrderFields()
updateOrderFields.StopPrice = newShortStop
updateOrderFields.Tag = "Update #{0}".format(len(shortOrder.UpdateRequests) + 1)
shortOrder.Update(updateOrderFields)
self.Log("Updated price - Long: {0} Short: {1}".format(longOrder.Get(OrderField.StopPrice), shortOrder.Get(OrderField.StopPrice)))
def StopLimitOrders(self):
'''StopLimitOrders work as a combined stop and limit order. First, the
price must pass the stop price in the same way a StopMarketOrder works,
but then we're also gauranteed a fill price at least as good as the
limit price. This order type can be beneficial in gap down scenarios
where a StopMarketOrder would have triggered and given the not as beneficial
gapped down price, whereas the StopLimitOrder could protect you from
getting 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 ticket
using the OrderTicket.Get(OrderField) method, for example:
Code:
currentStopPrice = orderTicket.Get(OrderField.StopPrice)
currentLimitPrice = orderTicket.Get(OrderField.LimitPrice)'''
if self.TimeIs(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
# gauranteed to get at least the limit price for our fills,
# so make the limit price a little higher than the stop price
close = self.Securities[self.spy.Value].Close
newTicket = self.StopLimitOrder(self.spy, 10, close * 1.001, close * 1.0025)
self.__openStopLimitOrders.append(newTicket)
# 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
# gauranteed to get at least the limit price for our fills,
# so make the limit price a little softer than the stop price
newTicket = self.StopLimitOrder(self.spy, -10, close * .999, close * 0.9975)
self.__openStopLimitOrders.append(newTicket)
# 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 processing
if len(self.__openStopLimitOrders) == 2:
longOrder = self.__openStopLimitOrders[0]
shortOrder = self.__openStopLimitOrders[1]
if self.CheckPairOrdersForFills(longOrder, shortOrder):
self.__openStopLimitOrders = []
return
# if neither order has filled, bring in the stops/limits in by a penny
newLongStop = longOrder.Get(OrderField.StopPrice) - 0.01
newLongLimit = longOrder.Get(OrderField.LimitPrice) + 0.01
newShortStop = shortOrder.Get(OrderField.StopPrice) + 0.01
newShortLimit = shortOrder.Get(OrderField.LimitPrice) - 0.01
self.Log("Updating stops - Long: {0:.2f} Short: {1:.2f}".format(newLongStop, newShortStop))
self.Log("Updating limits - Long: {0:.2f} Short: {1:.2f}".format(newLongLimit, newShortLimit))
updateOrderFields = UpdateOrderFields()
updateOrderFields.StopPrice = newLongStop
updateOrderFields.LimitPrice = newLongLimit
updateOrderFields.Tag = "Update #{0}".format(len(longOrder.UpdateRequests) + 1)
longOrder.Update(updateOrderFields)
updateOrderFields = UpdateOrderFields()
updateOrderFields.StopPrice = newShortStop
updateOrderFields.LimitPrice = newShortLimit
updateOrderFields.Tag = "Update #{0}".format(len(shortOrder.UpdateRequests) + 1)
shortOrder.Update(updateOrderFields)
def MarketOnCloseOrders(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.TimeIs(9, 12, 0):
self.Log("Submitting MarketOnCloseOrder")
# open a new position or triple our existing position
qty = self.Portfolio[self.spy.Value].Quantity
qty = 100 if qty == 0 else 2*qty
newTicket = self.MarketOnCloseOrder(self.spy, qty)
self.__openMarketOnCloseOrders.append(newTicket)
if len(self.__openMarketOnCloseOrders) == 1 and self.Time.minute == 59:
ticket = self.__openMarketOnCloseOrders[0]
# check for fills
if ticket.Status == OrderStatus.Filled:
self.__openMarketOnCloseOrders = []
return
quantity = ticket.Quantity + 1
self.Log("Updating quantity - New Quantity: {0}".format(quantity))
# we can update the quantity and tag
updateOrderFields = UpdateOrderFields()
updateOrderFields.Quantity = quantity
updateOrderFields.Tag = "Update #{0}".format(len(ticket.UpdateRequests) + 1)
ticket.Update(updateOrderFields)
if self.TimeIs(self.EndDate.day, 12 + 3, 45):
self.Log("Submitting MarketOnCloseOrder to liquidate end of algorithm")
self.MarketOnCloseOrder(self.spy, -self.Portfolio[self.spy.Value].Quantity, "Liquidate end of algorithm")
def MarketOnOpenOrders(self):
'''MarketOnOpenOrders are always executed at the next
market's opening price. The only properties that can
be updated are the quantity and order tag properties.'''
if self.TimeIs(8, 12 + 2, 0):
self.Log("Submitting MarketOnOpenOrder")
# its EOD, let's submit a market on open order to short even more!
newTicket = self.MarketOnOpenOrder(self.spy, 50)
self.__openMarketOnOpenOrders.append(newTicket)
if len(self.__openMarketOnOpenOrders) == 1 and self.Time.minute == 59:
ticket = self.__openMarketOnOpenOrders[0]
# check for fills
if ticket.Status == OrderStatus.Filled:
self.__openMarketOnOpenOrders = []
return
quantity = ticket.Quantity + 1
self.Log("Updating quantity - New Quantity: {0}".format(quantity))
# we can update the quantity and tag
updateOrderFields = UpdateOrderFields()
updateOrderFields.Quantity = quantity
updateOrderFields.Tag = "Update #{0}".format(len(ticket.UpdateRequests) + 1)
ticket.Update(updateOrderFields)
def OnOrderEvent(self, orderEvent):
order = self.Transactions.GetOrderById(orderEvent.OrderId)
self.Log("{0}: {1}: {2}".format(self.Time, order.Type, orderEvent))
def CheckPairOrdersForFills(self, longOrder, shortOrder):
if longOrder.Status == OrderStatus.Filled:
self.Log("{0}: Cancelling short order, long order is filled.".format(shortOrder.OrderType))
shortOrder.Cancel("Long filled.")
return True
if shortOrder.Status == OrderStatus.Filled:
self.Log("{0}: Cancelling long order, short order is filled.".format(longOrder.OrderType))
longOrder.Cancel("Short filled")
return True
return False
def TimeIs(self, day, hour, minute):
return self.Time.day == day and self.Time.hour == hour and self.Time.minute == minute