Overall Statistics Total Trades 3 Average Win 0% Average Loss 0% Compounding Annual Return 104555.077% Drawdown 27.600% Expectancy 0 Net Profit 33.076% Sharpe Ratio 4.01 Loss Rate 0% Win Rate 0% Profit-Loss Ratio 0 Alpha 4.231 Beta 138.851 Annual Standard Deviation 1.567 Annual Variance 2.455 Information Ratio 4.001 Tracking Error 1.567 Treynor Ratio 0.045 Total Fees \$18.50
```# QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
#
# you may not use this file except in compliance with the License.
#
# Unless required by applicable law or agreed to in writing, software
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and

from System import *
from QuantConnect import *
from QuantConnect.Algorithm import QCAlgorithm
from QuantConnect.Data.UniverseSelection import *

### <summary>
### Demonstration of using coarse and fine universe selection together to filter down a smaller universe of stocks.
### </summary>
### <meta name="tag" content="using data" />
### <meta name="tag" content="universes" />
### <meta name="tag" content="coarse universes" />
### <meta name="tag" content="fine universes" />
class CoarseFundamentalTop3Algorithm(QCAlgorithm):

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(2014,3,24)    #Set Start Date
self.SetEndDate(2014,4,7)      #Set End Date
self.SetCash(50000)            #Set Strategy Cash

# what resolution should the data *added* to the universe be?
self.UniverseSettings.Resolution = Resolution.Daily

# this add universe method accepts a single parameter that is a function that
# accepts an IEnumerable<CoarseFundamental> and returns IEnumerable<Symbol>

self.__numberOfSymbols = 3
self._changes = None

# sort the data by daily dollar volume and take the top 'NumberOfSymbols'
def CoarseSelectionFunction(self, coarse):
# sort descending by daily dollar volume
sortedByDollarVolume = sorted(coarse, key=lambda x: x.DollarVolume, reverse=True)

# return the symbol objects of the top entries from our sorted collection
return [ x.Symbol for x in sortedByDollarVolume[:self.__numberOfSymbols] ]

def OnData(self, slice):

#self.Log(f"OnData({self.UtcTime}): Keys: {', '.join([key.Value for key in data.Keys])}")

# if we have no changes, do nothing
if self._changes is None: return

# liquidate removed securities
for security in self._changes.RemovedSecurities:
if security.Invested:
self.option_symbol = option.Symbol

# set our strike/expiry filter for this option chain
option.SetFilter(-2, +2, timedelta(0), timedelta(180))

chain = slice.OptionChains.GetValue(self.option_symbol)
if chain is None:
return

# we sort the contracts to find at the money (ATM) contract with farthest expiration
contracts = sorted(sorted(sorted(chain, \
key = lambda x: abs(chain.Underlying.Price - x.Strike)), \
key = lambda x: x.Expiry, reverse=True), \
key = lambda x: x.Right, reverse=True)

if len(contracts) == 0: return
symbol = contracts[0].Symbol
self.Liquidate(symbol)
#self.MarketOrder(symbol, -1)

# we want 1/N allocation in each security in our universe

# when the added security is not Equity, continue.
if security.Type != SecurityType.Equity:
continue
self.option_symbol = option.Symbol

# set our strike/expiry filter for this option chain
option.SetFilter(-2, +2, timedelta(0), timedelta(180))

chain = slice.OptionChains.GetValue(self.option_symbol)
if chain is None:
return

# we sort the contracts to find at the money (ATM) contract with farthest expiration
contracts = sorted(sorted(sorted(chain, \
key = lambda x: abs(chain.Underlying.Price - x.Strike)), \
key = lambda x: x.Expiry, reverse=True), \
key = lambda x: x.Right, reverse=True)

if len(contracts) == 0: return
symbol = contracts[0].Symbol
self.SetHoldings(symbol, 1 / self.__numberOfSymbols)
#self.MarketOrder(symbol, 1)

self._changes = None

# this event fires whenever we have changes to our universe
def OnSecuritiesChanged(self, changes):
self._changes = changes
self.Log(f"OnSecuritiesChanged({self.UtcTime}):: {changes}")

def OnOrderEvent(self, fill):
self.Log(f"OnOrderEvent({self.UtcTime}):: {fill}")```