Migrating from Quantopian to QuantConnect

Core Functions
An algorithm on QuantConnect has 2 core functions: Initialize and OnData. On Initialize is mandatory.

Initialize
The Initialize method is called to setup your strategy. Here you can request data, set starting cash or warm up periods. It requires self as an input, since we need to use methods from the instance to setup our strategy:

OnData
Requested data is passed into event handlers for you to use to make trading decisions.
It is called one every time new data is available. If you have subscribed to minute data only, it will be called avery minute, if you have subscribed to daily data only, it will be called every day, etc...
It requires self and data. data is an object that groups all data types together at a single moment in time in the OnData(self, data) handler. Slice is short for "time slice" - representing a slice of time and values of the data at that time:

Referencing Securities
In QuantConnect we can subscribe to different asset types with different resolution and different "markets". For instance, we can select forex data from FXCM or Oanda. Please checkout the docs, under Asset Classes, for more detailed information about data subscription.
While Quantopian relies on the sid method to robustly refer to a security, since tickers can change, in QuantConnect we create an ID for each symbol for the same effect. The unique security symbol is mapped to the ticker you used to subscribe them and you can use both:

Ordering Securities
Algorithms can place an order through calling the appropriate method in the API. Going long is denoted with a ordering positive number, and short a negative one. LEAN does not support hedging (long and short at the same time).
Please checkout the docs, under Trading and Orders, for detailed information and a complete information.
In this post, we will focus on SetHoldings method which is equivalent to Quantopian's order_target_percent:

The quantity of shares used in SetHoldings is calculated by CalculateOrderQuantity method.

Thanks for the tips. Can you advise why am having trouble scheduling an event in Python? I get a error. (I'm on my phone, hard to add details now). 

Please disregard my last question. I think I found what I need on this sample Algo. 

... Link broken

The history() Function
In QuantConnect, Historical Data Requests are handled slightly different from Quantopian. While in Quantopian the history() function is a method from the data object that arrives in handle_data, QuantConnect's History method belongs to QCAlgorithm:

# Quantopain
# Get the 10-day trailing price history of AAPL in the form of a Series.
hist = data.history(sid(24), 'price', 10, '1d')

# Mean price over the last 10 days.
mean_price = hist.mean()

# QuantConnect
# Get the 10-day trailing bar history of AAPL in the form of list of bars
# Using the "symbol" method returns a list of tradebars.

hist = self.History("AAPL", 10, Resolution.Daily)
for bar in hist:
open = bar.Open

# Get the 10-day trailing bar history of AAPL in the form of pandas DataFrame
# Use a list of tickers to get back a pandas dataframe
hist = self.History(["AAPL"], 10, Resolution.Daily)

The following code snippets are working examples in each platform:

def initialize(context):
# AAPL, MSFT, SPY
context.security_list = [sid(24), sid(8554), sid(5061)]

def handle_data(context, data):
hist = data.history(context.security_list, 'volume', 10, '1m').mean()
print hist.mean()class MyAlgo(QCAlgorithm):
def Initialize(self):
self.AddEquity("SPY")
self.AddEquity("BAC")
self.AddEquity("IBM")
self.security_list = ["SPY", "BAC", "IBM"]

def OnData(self, data):
hist = self.History(self.security_list, 10, Resolution.Minute)
self.Log(str(hist['volume'].mean()))

Scheduling Functions
Scheduled events allow you to trigger code to run at specific times of day. This happens regardless of your data events. The schedule API requires a date and time rule to specify when the event is fired:

# Quantopian
schedule_function(func=rebalance,
date_rules=date_rules.every_day(),
time_rules=time_rules.market_open(hours=1))

# QuantConnect
self.Schedule.On(self.DateRules.EveryDay("SPY"),
self.TimeRules.AfterMarketOpen(self.spy, 60),
Action(self.rebalance))

Unlike Quantopian, the func does not require a data object:

def rebalance(self):
self.Log("EveryDay.SPY 60 min after open: Fired at: {0}".format(self.Time))

At this point, we need to introduce another member of QCAlgorithm: Securities. This object have the information about all the subcribed securities and can be accessed anywhere in the algorithm, unlike the Slice object that arrives at OnData:

def rebalance(self):
spy = self.Securities["SPY"]
price = spy.Price
self.Log("EveryDay.SPY 60 min after open: Fired at: {0}".format(self.Time))

The following working example takes a long position in SPY at the start of the week, and closes out the position at 3:30pm on the last day of the week:

def initialize(context):
context.spy = sid(8554)

schedule_function(open_positions, date_rules.week_start(), time_rules.market_open())
schedule_function(close_positions, date_rules.week_end(), time_rules.market_close(minutes=30))

def open_positions(context, data):
order_target_percent(context.spy, 0.10)

def close_positions(context, data):
order_target_percent(context.spy, 0)class MyAlgo(QCAlgorithm):
def Initialize(self):
AddEquity("SPY")

self.Schedule.On(self.DateRules.Every(DayOfWeek.Monday, DayOfWeek.Monday), \
self.TimeRules.AfterMarketOpen(self.spy), \
Action(self.open_positions))

self.Schedule.On(self.DateRules.Every(DayOfWeek.Friday, DayOfWeek.Friday), \
self.TimeRules.BeforeMarketClose(self.spy, 30), \
Action(self.close_positions))

def open_positions(self):
self.SetHoldings("SPY", 0.10)

def close_positions(self):
self.Liquidate("SPY")

From complete Date and Time rules, please checkout these reference tables. Since the equivalent date rule for week start and week end are missing, we can look into implementing it.

Managing Your Portfolio
Another key member in the QCAlgorithm is Portfolio. While Securities keep information about the securities that have been subscribed, Portfolio provides easy access to the holding properties. In order to know whether a security has an open position, we can look for the Invested/HoldStock member of SecurityHolding (Portfolio is an enhanced dictionary wihere the keys are the symbols and the value are SecurityHolding object).
Here is a simple example on how to close all open positions:

Yes, that is it. The Liquidate method, without any paramenter, will close all open positions.
Let now see how this is done in Quantopian and similarly in QuantConnect:

Plotting Variables

We provide a powerful charting API which can be build many chart types. At its simplest it can be used with a single line of code:

While Quantopian only allows one chart with some series, we allow many charts with some series two, since we can create more than one chart, add series into it and, finally, add the charts in the algorithm usinf AddChart method: 

Please checkout fully working backtest below.

Slippage and Commission
At the moment, it is not possible to customize slippage and commission in Python algorithm, despite the fact we can do it in C# algorithms. However, commission are modeled, by default, with the specifications from the brokerages.

Thank you for all you've written here so far, Alexandre. Regarding scheduling functions/events to run, is it possible to schedule a function/event before market open? I've tried with 

followed with 

my log keeps showing:

2017-02-22 09:31:00 :BTS

Managing Orders
In QCAlgorithm, all orders are recorded in the Transactions object. This object have several methods to select orders under any criteria:

# Cancel all open orders from SPY
cancelledOrders = self.Transactions.CancelOpenOrders("SPY")

# Cancel order #10
cancelledOrder = self.Transactions.CancelOrder(10)

# Get open orders
openOrders = self.Transactions.GetOpenOrders()

# Get open orders from SPY
openOrders = self.Transactions.GetOpenOrders("SPY")

# Get open order #10
openOrder = self.Transactions.GetOrderById(10)

# Get all orders
orders = self.Transactions.GetOrders()

# Get order ticket #10
orderTicket = self.Transactions.GetOrderTicket(10)

# Get all orders tickets
openOrderTickets = self.Transactions.GetOrderTickets()

Quantopian's API has three methods for managing existing orders: cancel_order(order), get_open_orders(sid) and get_order(order). For this thread, let's compare the methods for getting open orders in a working example:

# Quantopian
def initialize(context):
    # Relatively illiquid stock.
    context.xtl = sid(40768)

def handle_data(context, data):
    # Get all open orders.
    open_orders = get_open_orders()

    if context.xtl not in open_orders and data.can_trade(context.xtl):
        order_target_percent(context.xtl, 1.0)

# QuantConnect
class MyAlgo(QCAlgorithm):
    def Initialize(self):
        # Relatively illiquid stock.
        self.AddEquity("XTL")

    def OnData(self, data):
        # Get all open orders.
        open_orders = self.Transactions.GetOpenOrders()

        if len(open_orders) == 0 and not Portfolio.Invested:
            self.SetHoldings("XTL", 1)

Demo Algorithm 1; Simple SMA Weekly Mean-reversion Strategy

This algorithm calculates 30-day SMA and 10-day SMA for each stock and it's rebalanced weekly. Every Monday if the 10-day SMA is higher than the 30-day SMA, I short the stock, and vice versa. 

Thanks Alexandre! Really appreciate the quality of your guide with parallel examples between the two IDE's

If it's possible in QC, could you cover the equivalent implementation of Quantopian's Pipeline API for filtering down a large universe of securities based on custom factors and fundamental data?

So if someone could help me out. If I am understanding this right, I should get a print on logs at the start of everymonth right?

Jonathan Gomez - Almost. Because we are multi-asset each asset has a different start of month. So for that method you need to remember to 1) add the assets to the algorithm, and 2) specify start of month for which security. See this example algorithm attached.  

Thanks for starting this thread, very informative.

Can you give an example of an equivalent of Quantopian pipeline with fundamentals data. Like for example selecting universe of top decile stocks by daily volume that had positive earnings in last quarter?

Does Quantconnect have any limits on account sizes connected to IB?

Data Normalization Mode
By default, equity prices are adjusted in QuantConnect for all resolutions.
If we want Raw prices, we need to set the data normalization mode for each equity:

Up next: Universe Selection (QuantConnect's equivalent to Quantopian's Pipeline)

Dynamic Security Selection
Pipeline is the name Quantopian has choosen for the dynamic security selection feature. In QuantConnect, we call it Universe Selection. Before we show how the differences, here is how this feature is used in each platform:

# Quantopian
from quantopian.pipeline import Pipeline
from quantopian.algorithm import attach_pipeline, pipeline_output

def initialize(context):
    my_pipe = make_pipeline()
    attach_pipeline(my_pipe, 'my_pipeline')

def make_pipeline():
    return Pipeline()

def before_trading_start(context, data):
    # Store our pipeline output DataFrame in context.
    context.output = pipeline_output('my_pipeline')

# QuantConnect
from System.Collections.Generic import List
from QuantConnect.Data.UniverseSelection import *

class MyAlgorithm(QCAlgorithm):
    def Initialize(self):
        self.AddUniverse(self.CoarseSelectionFunction)

    def CoarseSelectionFunction(self, coarse):
        sortedByDollarVolume = sorted(coarse, key=lambda x: x.DollarVolume, reverse=True)

        list = List[Symbol]()
        for c in sortedByDollarVolume[:5]: list.Add(c.Symbol)
        return list

    # this event fires whenever we have changes to our universe
    def OnSecuritiesChanged(self, changes):
        self.changes = changes

In QuantConnect, the AddUniverse method is used to pass a function that selects the securities from a pre-defined universe passed as 'coarse'. The coarse object is a CoarseFundamental type, please checkout the docs for more information. Once the universe members change, the OnSecuritiesChanged event handler is triggered. We can make trading decisions and place orders in this method:

Pipeline relies heavily on pandas Dataframe and has a lot of build-in factors (based on indicators) that can be used to define filters and classifiers. In QuantConnect, we need to combine our indicators to select the securities.

Dynamic Security Selection - Fundamental Data
At the moment, we can only get fundamental data for universe selection. To access it, we need to add a function as a second parameter in AddUniverse that will receive fine fundamental data from the universe that was pre-filtered by Coarse Fundamental:

Please checkout a fully working example below.