Overall Statistics Total Trades0Average Win0%Average Loss0%Compounding Annual Return0%Drawdown0%Expectancy0Net Profit0%Sharpe Ratio0Loss Rate0%Win Rate0%Profit-Loss Ratio0Alpha0Beta0Annual Standard Deviation0Annual Variance0Information Ratio0Tracking Error0Treynor Ratio0Total Fees\$0.00
```import numpy as np
from pprint import pprint
import pandas as pd
from datetime import timedelta, date, datetime

### <summary>
### Basic template algorithm simply initializes the date range and cash. This is a skeleton
### framework you can use for designing an algorithm.
### </summary>
class BasicTemplateAlgorithm(QCAlgorithm):
'''Basic template algorithm simply initializes the date range and cash'''

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(2016,10,01)  #Set Start Date
self.SetEndDate(2016,11,8)    #Set End Date
self.SetCash(25000)           #Set Strategy Cash
# Find more symbols here: http://quantconnect.com/data

# option.SetFilter(-2, 2, TimeSpan.FromDays(30), TimeSpan.FromDays(180));
self.Schedule.On(self.DateRules.Every([DayOfWeek.Thursday]), self.TimeRules.BeforeMarketClose("SPY", 45), Action(self.Activate))

def CoarseSelectionFunction(self, coarse):
'''Take the top 5 by dollar volume using coarse'''
# sort descending by daily dollar volume
sortedByDollarVolume = sorted(coarse, \
key=lambda x: x.DollarVolume, reverse=True)

# we need to return only the symbol objects
return [ x.Symbol for x in sortedByDollarVolume[:5] ]

def OnSecuritiesChanged (self, changes):
if x.Symbol.SecurityType != SecurityType.Equity: continue
option.SetFilter(-1, +1, timedelta(6), timedelta(15))

for x in changes.RemovedSecurities:
# if x.Symbol.SecurityType != SecurityType.Equity: continue
# Loop through the securities
# If it is an option and the underlying matches the removed security, remove it
for symbol in self.Securities.Keys:
if symbol.SecurityType == SecurityType.Option and symbol.Underlying == x.Symbol:
self.Log("trying to remove here")
self.Log(str(symbol))
self.RemoveSecurity(symbol)

def Activate(self):

def OnData(self,slice):
return

self.Log("Doing it")

# spyTickList = slice["SPY"]
# self.Log(str(spyTickList))

k = 0
for i in slice.OptionChains:
k += 1
self.Log(str(k))
optionchain = i.Value
# print out the undelying price
self.Log("underlying price:" + str(optionchain.Underlying.Price))

# create a data frame to show the filtered contracts
# type(call 0, put 1)
df = pd.DataFrame([[x.Right,float(x.Strike),x.Expiry,float(x.BidPrice), float(x.AskPrice)] for x in optionchain],
index=[x.Symbol.Value for x in optionchain],
columns=['type', 'strike', 'expiry', 'ask price', 'bid price'])

#day lag
date_format = "%Y-%m-%d"
# day_lag = ( df.sort('expiry', ascending=True).iloc[0]['expiry'] - date.today() ).days

#get history
# hist = self.History( ["SPY"], 10, Resolution.Daily )
# self.Log(str(hist.loc[ "SPY" ].close))

#get interesting contracts
contracts = df.loc[ df['strike'] > optionchain.Underlying.Price ].iloc[:2]

# self.Log(str(contracts))

# we sort the contracts to find at the money (ATM) contract with farthest expiration
contracts = sorted(sorted(optionchain, key = lambda x: abs(optionchain.Underlying.Price - x.Strike)),key = lambda x: x.Expiry, reverse=True)
# buy the option with farthest expiration and sell it when the exchange closes
if len(contracts) == 0: continue
symbol = contracts[0].Symbol
#self.MarketOrder(symbol, 1)
#self.MarketOnCloseOrder(symbol, -1)