Update Research Images with Newer Jupyter

Drop Watchlist

Remove breakpoints from lean

Prep install of NetCoreDbg

Cleanup

.github/workflows/gh-actions.yml

@@ -28,3 +28,5 @@ jobs:
           ./ci_build_stubs.sh -t -g -p
         env:
           PYPI_API_TOKEN: ${{ secrets.PYPI_API_TOKEN }}
+          ADDITIONAL_STUBS_REPOS: ${{ secrets.ADDITIONAL_STUBS_REPOS }}
+          QC_GIT_TOKEN: ${{ secrets.QC_GIT_TOKEN }}

.vscode/launch.json

@@ -8,8 +8,8 @@
         marketplace.
 
         Attach to Python:
-        Will attempt to attach to LEAN running locally using PTVSD. Requires that the process is
-        actively running and config is set: "debugging": true, "debugging-method": "PTVSD",
+        Will attempt to attach to LEAN running locally using DebugPy. Requires that the process is
+        actively running and config is set: "debugging": true, "debugging-method": "DebugPy",
         Requires Python extension from the marketplace. Currently only works with algorithms in
         Algorithm.Python directory. This is because we map that directory to our build directory
         that contains the py file at runtime. If using another location change "localRoot" value 

.vscode/readme.md

@@ -95,7 +95,7 @@ Python algorithms require a little extra work in order to be able to debug them.
 First in order to debug a Python algorithm in VS Code we must make the following change to our configuration (Launcher\config.json) under the comment debugging configuration:
 
     "debugging": true,
-    "debugging-method": "PTVSD",
+    "debugging-method": "DebugPy,
 
 In setting this we are telling Lean to expect a debugger connection using ‘Python Tools for Visual Studio Debugger’. Once this is set Lean will stop upon initialization and await a connection to the debugger via port 5678.
 

Algorithm.CSharp/AddAlphaModelAlgorithm.cs

@@ -117,18 +117,18 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "1.700%"},
             {"Expectancy", "1.781"},
             {"Net Profit", "1.442%"},
-            {"Sharpe Ratio", "4.017"},
-            {"Probabilistic Sharpe Ratio", "59.636%"},
+            {"Sharpe Ratio", "4.86"},
+            {"Probabilistic Sharpe Ratio", "59.497%"},
             {"Loss Rate", "33%"},
             {"Win Rate", "67%"},
             {"Profit-Loss Ratio", "3.17"},
-            {"Alpha", "1.53"},
-            {"Beta", "-0.292"},
-            {"Annual Standard Deviation", "0.279"},
-            {"Annual Variance", "0.078"},
-            {"Information Ratio", "-0.743"},
-            {"Tracking Error", "0.372"},
-            {"Treynor Ratio", "-3.845"},
+            {"Alpha", "4.181"},
+            {"Beta", "-1.322"},
+            {"Annual Standard Deviation", "0.321"},
+            {"Annual Variance", "0.103"},
+            {"Information Ratio", "-0.795"},
+            {"Tracking Error", "0.532"},
+            {"Treynor Ratio", "-1.18"},
             {"Total Fees", "$14.78"},
             {"Estimated Strategy Capacity", "$47000000.00"},
             {"Lowest Capacity Asset", "IBM R735QTJ8XC9X"},

Algorithm.CSharp/AddAndRemoveOptionContractRegressionAlgorithm.cs

@@ -103,8 +103,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Beta", "0"},
             {"Annual Standard Deviation", "0"},
             {"Annual Variance", "0"},
-            {"Information Ratio", "0"},
-            {"Tracking Error", "0"},
+            {"Information Ratio", "-9.486"},
+            {"Tracking Error", "0.008"},
             {"Treynor Ratio", "0"},
             {"Total Fees", "$0.00"},
             {"Estimated Strategy Capacity", "$0"},

Algorithm.CSharp/AddAndRemoveSecuritySameLoopRegressionAlgorithm.cs

@@ -0,0 +1,131 @@
+/*
+ * 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.
+*/
+
+using System;
+using System.Linq;
+using QuantConnect.Data;
+using QuantConnect.Interfaces;
+using System.Collections.Generic;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Regression algorithm reproducing GH issue #5971 where we add and remove an option in the same loop
+    /// </summary>
+    public class AddAndRemoveSecuritySameLoopRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Symbol _contract;
+        private bool _hasRemoved;
+
+        public override void Initialize()
+        {
+            SetStartDate(2014, 06, 06);
+            SetEndDate(2014, 06, 09);
+
+            UniverseSettings.DataNormalizationMode = DataNormalizationMode.Raw;
+            UniverseSettings.MinimumTimeInUniverse = TimeSpan.Zero;
+
+            var aapl = AddEquity("AAPL").Symbol;
+
+            _contract = OptionChainProvider.GetOptionContractList(aapl, Time)
+                .OrderBy(symbol => symbol.ID.Symbol)
+                .FirstOrDefault(optionContract => optionContract.ID.OptionRight == OptionRight.Call
+                    && optionContract.ID.OptionStyle == OptionStyle.American);
+        }
+
+        public override void OnData(Slice slice)
+        {
+            if (_hasRemoved)
+            {
+                throw new Exception("Expect a single call to OnData where we removed the option and underlying");
+            }
+
+            _hasRemoved = true;
+            AddOptionContract(_contract);
+
+            // changed my mind!
+            RemoveOptionContract(_contract);
+            RemoveSecurity(_contract.Underlying);
+
+            RemoveSecurity(AddEquity("SPY", Resolution.Daily).Symbol);
+        }
+        public override void OnEndOfAlgorithm()
+        {
+            if (!_hasRemoved)
+            {
+                throw new Exception("We did not remove the option contract!");
+            }
+        }
+
+        /// <summary>
+        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
+        /// </summary>
+        public bool CanRunLocally { get; } = true;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public Language[] Languages { get; } = { Language.CSharp };
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        {
+            {"Total Trades", "0"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "0%"},
+            {"Drawdown", "0%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "0%"},
+            {"Sharpe Ratio", "0"},
+            {"Probabilistic Sharpe Ratio", "0%"},
+            {"Loss Rate", "0%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "0"},
+            {"Beta", "0"},
+            {"Annual Standard Deviation", "0"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "-9.486"},
+            {"Tracking Error", "0.008"},
+            {"Treynor Ratio", "0"},
+            {"Total Fees", "$0.00"},
+            {"Estimated Strategy Capacity", "$0"},
+            {"Lowest Capacity Asset", ""},
+            {"Fitness Score", "0"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "79228162514264337593543950335"},
+            {"Return Over Maximum Drawdown", "79228162514264337593543950335"},
+            {"Portfolio Turnover", "0"},
+            {"Total Insights Generated", "0"},
+            {"Total Insights Closed", "0"},
+            {"Total Insights Analysis Completed", "0"},
+            {"Long Insight Count", "0"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "$0"},
+            {"Total Accumulated Estimated Alpha Value", "$0"},
+            {"Mean Population Estimated Insight Value", "$0"},
+            {"Mean Population Direction", "0%"},
+            {"Mean Population Magnitude", "0%"},
+            {"Rolling Averaged Population Direction", "0%"},
+            {"Rolling Averaged Population Magnitude", "0%"},
+            {"OrderListHash", "d41d8cd98f00b204e9800998ecf8427e"}
+        };
+    }
+}

Algorithm.CSharp/AddBetaIndicatorRegressionAlgorithm.cs

@@ -0,0 +1,151 @@
+/*
+ * 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.
+*/
+
+using System;
+using System.Collections.Generic;
+using QuantConnect.Data;
+using QuantConnect.Indicators;
+using QuantConnect.Interfaces;
+using QuantConnect.Orders;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Regression test to explain how Beta indicator works
+    /// </summary>
+    public class AddBetaIndicatorRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Beta _beta;
+        private SimpleMovingAverage _sma;
+        private decimal _lastSMAValue;
+
+        public override void Initialize()
+        {
+            SetStartDate(2013, 10, 07);
+            SetEndDate(2013, 10, 15);
+            SetCash(10000);
+
+            AddEquity("IBM");
+            AddEquity("SPY");
+
+            EnableAutomaticIndicatorWarmUp = true;
+            _beta = B("IBM", "SPY", 3, Resolution.Daily);
+            _sma = SMA("SPY", 3, Resolution.Daily);
+            _lastSMAValue = 0;
+
+            if (!_beta.IsReady)
+            {
+                throw new Exception("_beta indicator was expected to be ready");
+            }
+        }
+
+        public override void OnData(Slice data)
+        {
+            if (!Portfolio.Invested)
+            {
+                var price = data["IBM"].Close;
+                Buy("IBM", 10);
+                LimitOrder("IBM", 10, price * 0.1m);
+                StopMarketOrder("IBM", 10, price / 0.1m);
+            }
+            
+            if (_beta.Current.Value < 0m || _beta.Current.Value > 2.80m)
+            {
+                throw new Exception($"_beta value was expected to be between 0 and 2.80 but was {_beta.Current.Value}");
+            }
+
+            Log($"Beta between IBM and SPY is: {_beta.Current.Value}");
+        }
+
+        public override void OnOrderEvent(OrderEvent orderEvent)
+        {
+            var order = Transactions.GetOrderById(orderEvent.OrderId);
+            var goUpwards = _lastSMAValue < _sma.Current.Value;
+            _lastSMAValue = _sma.Current.Value;
+
+            if (order.Status == OrderStatus.Filled)
+            {
+                if (order.Type == OrderType.Limit && Math.Abs(_beta.Current.Value - 1) < 0.2m && goUpwards)
+                {
+                    Transactions.CancelOpenOrders(order.Symbol);
+                }
+            }
+
+            if (order.Status == OrderStatus.Canceled)
+            {
+                Log(orderEvent.ToString());
+            }
+        }
+
+        /// <summary>
+        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
+        /// </summary>
+        public bool CanRunLocally { get; } = true;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public virtual Language[] Languages { get; } = { Language.CSharp};
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        {
+            {"Total Trades", "1"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "12.939%"},
+            {"Drawdown", "0.300%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "0.289%"},
+            {"Sharpe Ratio", "4.233"},
+            {"Probabilistic Sharpe Ratio", "68.349%"},
+            {"Loss Rate", "0%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "0.035"},
+            {"Beta", "0.122"},
+            {"Annual Standard Deviation", "0.024"},
+            {"Annual Variance", "0.001"},
+            {"Information Ratio", "-3.181"},
+            {"Tracking Error", "0.142"},
+            {"Treynor Ratio", "0.842"},
+            {"Total Fees", "$1.00"},
+            {"Estimated Strategy Capacity", "$35000000.00"},
+            {"Lowest Capacity Asset", "IBM R735QTJ8XC9X"},
+            {"Fitness Score", "0.022"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "8.508"},
+            {"Return Over Maximum Drawdown", "58.894"},
+            {"Portfolio Turnover", "0.022"},
+            {"Total Insights Generated", "0"},
+            {"Total Insights Closed", "0"},
+            {"Total Insights Analysis Completed", "0"},
+            {"Long Insight Count", "0"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "$0"},
+            {"Total Accumulated Estimated Alpha Value", "$0"},
+            {"Mean Population Estimated Insight Value", "$0"},
+            {"Mean Population Direction", "0%"},
+            {"Mean Population Magnitude", "0%"},
+            {"Rolling Averaged Population Direction", "0%"},
+            {"Rolling Averaged Population Magnitude", "0%"},
+            {"OrderListHash", "bd88c6a0e10c7e146b05377205101a12"}
+        };
+    }
+}

Algorithm.CSharp/AddFutureContractWithContinuousRegressionAlgorithm.cs

@@ -0,0 +1,165 @@
+/*
+ * 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.
+*/
+
+using System;
+using System.Linq;
+using QuantConnect.Data;
+using QuantConnect.Orders;
+using QuantConnect.Interfaces;
+using QuantConnect.Securities;
+using System.Collections.Generic;
+using QuantConnect.Securities.Future;
+using QuantConnect.Data.UniverseSelection;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Continuous Futures Regression algorithm. Asserting and showcasing the behavior of adding a continuous future
+    /// and a future contract at the same time
+    /// </summary>
+    public class AddFutureContractWithContinuousRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Symbol _currentMappedSymbol;
+        private Future _continuousContract;
+        private Future _futureContract;
+        private bool _ended;
+
+        /// <summary>
+        /// Initialise the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must initialized.
+        /// </summary>
+        public override void Initialize()
+        {
+            SetStartDate(2013, 10, 6);
+            SetEndDate(2013, 10, 10);
+
+            _continuousContract = AddFuture(Futures.Indices.SP500EMini,
+                dataNormalizationMode: DataNormalizationMode.BackwardsRatio,
+                dataMappingMode: DataMappingMode.LastTradingDay,
+                contractDepthOffset: 0
+            );
+
+            _futureContract = AddFutureContract(FutureChainProvider.GetFutureContractList(_continuousContract.Symbol, Time).First());
+        }
+
+        /// <summary>
+        /// OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here.
+        /// </summary>
+        /// <param name="data">Slice object keyed by symbol containing the stock data</param>
+        public override void OnData(Slice data)
+        {
+            if (_ended)
+            {
+                throw new Exception($"Algorithm should of ended!");
+            }
+            if (data.Keys.Count > 2)
+            {
+                throw new Exception($"Getting data for more than 2 symbols! {string.Join(",", data.Keys.Select(symbol => symbol))}");
+            }
+            if (UniverseManager.Count != 3)
+            {
+                throw new Exception($"Expecting 3 universes (chain, continuous and user defined) but have {UniverseManager.Count}");
+            }
+
+            if (!Portfolio.Invested)
+            {
+                Buy(_futureContract.Symbol, 1);
+                Buy(_continuousContract.Mapped, 1);
+
+                RemoveSecurity(_futureContract.Symbol);
+                RemoveSecurity(_continuousContract.Symbol);
+
+                _ended = true;
+            }
+        }
+
+        public override void OnOrderEvent(OrderEvent orderEvent)
+        {
+            if (orderEvent.Status == OrderStatus.Filled)
+            {
+                Log($"{orderEvent}");
+            }
+        }
+
+        public override void OnSecuritiesChanged(SecurityChanges changes)
+        {
+            Debug($"{Time}-{changes}");
+
+            if (changes.AddedSecurities.Any(security => security.Symbol != _continuousContract.Symbol && security.Symbol != _futureContract.Symbol)
+                || changes.RemovedSecurities.Any(security => security.Symbol != _continuousContract.Symbol && security.Symbol != _futureContract.Symbol))
+            {
+                throw new Exception($"We got an unexpected security changes {changes}");
+            }
+        }
+
+        /// <summary>
+        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
+        /// </summary>
+        public bool CanRunLocally { get; } = true;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public Language[] Languages { get; } = { Language.CSharp };
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        {
+            {"Total Trades", "3"},
+            {"Average Win", "0%"},
+            {"Average Loss", "-0.03%"},
+            {"Compounding Annual Return", "-2.503%"},
+            {"Drawdown", "0.000%"},
+            {"Expectancy", "-1"},
+            {"Net Profit", "-0.032%"},
+            {"Sharpe Ratio", "0"},
+            {"Probabilistic Sharpe Ratio", "0%"},
+            {"Loss Rate", "100%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "0"},
+            {"Beta", "0"},
+            {"Annual Standard Deviation", "0"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "-0.678"},
+            {"Tracking Error", "0.243"},
+            {"Treynor Ratio", "0"},
+            {"Total Fees", "$7.40"},
+            {"Estimated Strategy Capacity", "$2100000.00"},
+            {"Lowest Capacity Asset", "ES VMKLFZIH2MTD"},
+            {"Fitness Score", "0.419"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "79228162514264337593543950335"},
+            {"Return Over Maximum Drawdown", "-81.557"},
+            {"Portfolio Turnover", "0.837"},
+            {"Total Insights Generated", "0"},
+            {"Total Insights Closed", "0"},
+            {"Total Insights Analysis Completed", "0"},
+            {"Long Insight Count", "0"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "$0"},
+            {"Total Accumulated Estimated Alpha Value", "$0"},
+            {"Mean Population Estimated Insight Value", "$0"},
+            {"Mean Population Direction", "0%"},
+            {"Mean Population Magnitude", "0%"},
+            {"Rolling Averaged Population Direction", "0%"},
+            {"Rolling Averaged Population Magnitude", "0%"},
+            {"OrderListHash", "68775c18eb40c1bde212653faec4016e"}
+        };
+    }
+}

Algorithm.CSharp/AddFutureOptionContractDataStreamingRegressionAlgorithm.cs

@@ -40,7 +40,7 @@ namespace QuantConnect.Algorithm.CSharp
 
         public override void Initialize()
         {
-            SetStartDate(2020, 1, 5);
+            SetStartDate(2020, 1, 4);
             SetEndDate(2020, 1, 6);
 
             _es20h20 = AddFutureContract(
@@ -51,7 +51,7 @@ namespace QuantConnect.Algorithm.CSharp
                 QuantConnect.Symbol.CreateFuture(Futures.Indices.SP500EMini, Market.CME, new DateTime(2020, 6, 19)),
                 Resolution.Minute).Symbol;
 
-            var optionChains = OptionChainProvider.GetOptionContractList(_es20h20, Time)
+            var optionChains = OptionChainProvider.GetOptionContractList(_es20h20, Time.AddDays(1))
                 .Concat(OptionChainProvider.GetOptionContractList(_es19m20, Time));
 
             foreach (var optionContract in optionChains)
@@ -168,31 +168,31 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "2"},
             {"Average Win", "0%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "217.585%"},
+            {"Compounding Annual Return", "116.059%"},
             {"Drawdown", "0.600%"},
             {"Expectancy", "0"},
             {"Net Profit", "0.635%"},
-            {"Sharpe Ratio", "0"},
+            {"Sharpe Ratio", "17.16"},
             {"Probabilistic Sharpe Ratio", "0%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "0"},
-            {"Beta", "0"},
-            {"Annual Standard Deviation", "0"},
-            {"Annual Variance", "0"},
-            {"Information Ratio", "-14.395"},
-            {"Tracking Error", "0.043"},
-            {"Treynor Ratio", "0"},
+            {"Alpha", "2.25"},
+            {"Beta", "-1.665"},
+            {"Annual Standard Deviation", "0.071"},
+            {"Annual Variance", "0.005"},
+            {"Information Ratio", "5.319"},
+            {"Tracking Error", "0.114"},
+            {"Treynor Ratio", "-0.735"},
             {"Total Fees", "$7.40"},
-            {"Estimated Strategy Capacity", "$28000000.00"},
+            {"Estimated Strategy Capacity", "$24000000.00"},
             {"Lowest Capacity Asset", "ES XFH59UK0MYO1"},
             {"Fitness Score", "1"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
             {"Sortino Ratio", "79228162514264337593543950335"},
             {"Return Over Maximum Drawdown", "79228162514264337593543950335"},
-            {"Portfolio Turnover", "3.199"},
+            {"Portfolio Turnover", "2.133"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
             {"Total Insights Analysis Completed", "0"},

Algorithm.CSharp/AddFutureOptionSingleOptionChainSelectedInUniverseFilterRegressionAlgorithm.cs

@@ -42,7 +42,7 @@ namespace QuantConnect.Algorithm.CSharp
 
         public override void Initialize()
         {
-            SetStartDate(2020, 1, 5);
+            SetStartDate(2020, 1, 4);
             SetEndDate(2020, 1, 6);
 
             _es = AddFuture(Futures.Indices.SP500EMini, Resolution.Minute, Market.CME);
@@ -227,31 +227,31 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "2"},
             {"Average Win", "0%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "-15.625%"},
+            {"Compounding Annual Return", "-10.708%"},
             {"Drawdown", "0.200%"},
             {"Expectancy", "0"},
             {"Net Profit", "-0.093%"},
-            {"Sharpe Ratio", "-11.181"},
+            {"Sharpe Ratio", "-10.594"},
             {"Probabilistic Sharpe Ratio", "0%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "0.002"},
-            {"Beta", "-0.016"},
-            {"Annual Standard Deviation", "0.001"},
+            {"Alpha", "-0.261"},
+            {"Beta", "0.244"},
+            {"Annual Standard Deviation", "0.01"},
             {"Annual Variance", "0"},
-            {"Information Ratio", "-14.343"},
-            {"Tracking Error", "0.044"},
-            {"Treynor Ratio", "0.479"},
+            {"Information Ratio", "-22.456"},
+            {"Tracking Error", "0.032"},
+            {"Treynor Ratio", "-0.454"},
             {"Total Fees", "$3.70"},
             {"Estimated Strategy Capacity", "$41000.00"},
             {"Lowest Capacity Asset", "ES 31C3JQTOYO9T0|ES XCZJLC9NOB29"},
-            {"Fitness Score", "0.41"},
+            {"Fitness Score", "0.273"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
             {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "-185.654"},
-            {"Portfolio Turnover", "0.821"},
+            {"Return Over Maximum Drawdown", "-123.159"},
+            {"Portfolio Turnover", "0.547"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
             {"Total Insights Analysis Completed", "0"},

Algorithm.CSharp/AddOptionContractExpiresRegressionAlgorithm.cs

@@ -126,21 +126,21 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "0.300%"},
             {"Expectancy", "-0.042"},
             {"Net Profit", "-0.332%"},
-            {"Sharpe Ratio", "-3.7"},
-            {"Probabilistic Sharpe Ratio", "0.563%"},
+            {"Sharpe Ratio", "-3.149"},
+            {"Probabilistic Sharpe Ratio", "0.427%"},
             {"Loss Rate", "50%"},
             {"Win Rate", "50%"},
             {"Profit-Loss Ratio", "0.92"},
-            {"Alpha", "-0.021"},
-            {"Beta", "-0.011"},
-            {"Annual Standard Deviation", "0.006"},
+            {"Alpha", "-0.015"},
+            {"Beta", "-0.012"},
+            {"Annual Standard Deviation", "0.005"},
             {"Annual Variance", "0"},
-            {"Information Ratio", "-3.385"},
-            {"Tracking Error", "0.058"},
-            {"Treynor Ratio", "2.117"},
+            {"Information Ratio", "-2.823"},
+            {"Tracking Error", "0.049"},
+            {"Treynor Ratio", "1.372"},
             {"Total Fees", "$2.00"},
-            {"Estimated Strategy Capacity", "$45000000.00"},
-            {"Lowest Capacity Asset", "AOL R735QTJ8XC9X"},
+            {"Estimated Strategy Capacity", "$67000000.00"},
+            {"Lowest Capacity Asset", "AOL VRKS95ENLBYE|AOL R735QTJ8XC9X"},
             {"Fitness Score", "0"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
@@ -160,7 +160,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "b006bb7864c0b2f1a6552fb2aa7f03b8"}
+            {"OrderListHash", "4f50b8360ea317ef974801649088bd06"}
         };
     }
 }

Algorithm.CSharp/AddOptionContractTwiceRegressionAlgorithm.cs

@@ -0,0 +1,165 @@
+/*
+ * 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.
+*/
+
+using System;
+using System.Linq;
+using QuantConnect.Data;
+using QuantConnect.Interfaces;
+using System.Collections.Generic;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Regression algorithm reproducing GH issue #6073 where we remove and re add an option and expect it to work
+    /// </summary>
+    public class AddOptionContractTwiceRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Symbol _contract;
+        private bool _hasRemoved;
+        private bool _reAdded;
+
+        public override void Initialize()
+        {
+            SetStartDate(2014, 06, 06);
+            SetEndDate(2014, 06, 09);
+
+            UniverseSettings.DataNormalizationMode = DataNormalizationMode.Raw;
+            UniverseSettings.MinimumTimeInUniverse = TimeSpan.Zero;
+            UniverseSettings.FillForward = false;
+
+            AddEquity("SPY", Resolution.Daily);
+
+            var aapl = QuantConnect.Symbol.Create("AAPL", SecurityType.Equity, Market.USA);
+
+            _contract = OptionChainProvider.GetOptionContractList(aapl, Time)
+                .OrderBy(symbol => symbol.ID.Symbol)
+                .FirstOrDefault(optionContract => optionContract.ID.OptionRight == OptionRight.Call
+                    && optionContract.ID.OptionStyle == OptionStyle.American);
+            AddOptionContract(_contract);
+        }
+
+        public override void OnData(Slice slice)
+        {
+            if (_hasRemoved)
+            {
+                if (!_reAdded && slice.ContainsKey(_contract) && slice.ContainsKey(_contract.Underlying))
+                {
+                    throw new Exception("Getting data for removed option and underlying!");
+                }
+
+                if (!Portfolio.Invested && _reAdded)
+                {
+                    var option = Securities[_contract];
+                    var optionUnderlying = Securities[_contract.Underlying];
+                    if (option.IsTradable && optionUnderlying.IsTradable
+                        && slice.ContainsKey(_contract) && slice.ContainsKey(_contract.Underlying))
+                    {
+                        Buy(_contract, 1);
+                    }
+                }
+
+                if (!Securities[_contract].IsTradable
+                    && !Securities[_contract.Underlying].IsTradable
+                    && !_reAdded)
+                {
+                    // ha changed my mind!
+                    AddOptionContract(_contract);
+                    _reAdded = true;
+                }
+            }
+
+            if (slice.ContainsKey(_contract) && slice.ContainsKey(_contract.Underlying))
+            {
+                if (!_hasRemoved)
+                {
+                    RemoveOptionContract(_contract);
+                    RemoveSecurity(_contract.Underlying);
+                    _hasRemoved = true;
+                }
+            }
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            if (!_hasRemoved)
+            {
+                throw new Exception("We did not remove the option contract!");
+            }
+            if (!_reAdded)
+            {
+                throw new Exception("We did not re add the option contract!");
+            }
+        }
+
+        /// <summary>
+        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
+        /// </summary>
+        public bool CanRunLocally { get; } = true;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public Language[] Languages { get; } = { Language.CSharp };
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        {
+            {"Total Trades", "2"},
+            {"Average Win", "0%"},
+            {"Average Loss", "-0.05%"},
+            {"Compounding Annual Return", "-4.548%"},
+            {"Drawdown", "0.100%"},
+            {"Expectancy", "-1"},
+            {"Net Profit", "-0.051%"},
+            {"Sharpe Ratio", "0"},
+            {"Probabilistic Sharpe Ratio", "0%"},
+            {"Loss Rate", "100%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "0"},
+            {"Beta", "0"},
+            {"Annual Standard Deviation", "0"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "-9.486"},
+            {"Tracking Error", "0.008"},
+            {"Treynor Ratio", "0"},
+            {"Total Fees", "$2.00"},
+            {"Estimated Strategy Capacity", "$30000.00"},
+            {"Lowest Capacity Asset", "AAPL VXBK4Q9ZIFD2|AAPL R735QTJ8XC9X"},
+            {"Fitness Score", "0"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "79228162514264337593543950335"},
+            {"Return Over Maximum Drawdown", "-89.181"},
+            {"Portfolio Turnover", "0"},
+            {"Total Insights Generated", "0"},
+            {"Total Insights Closed", "0"},
+            {"Total Insights Analysis Completed", "0"},
+            {"Long Insight Count", "0"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "$0"},
+            {"Total Accumulated Estimated Alpha Value", "$0"},
+            {"Mean Population Estimated Insight Value", "$0"},
+            {"Mean Population Direction", "0%"},
+            {"Mean Population Magnitude", "0%"},
+            {"Rolling Averaged Population Direction", "0%"},
+            {"Rolling Averaged Population Magnitude", "0%"},
+            {"OrderListHash", "7fbcd12db40304d50b3a34d7878eb3cf"}
+        };
+    }
+}

Algorithm.CSharp/AddRemoveOptionUniverseRegressionAlgorithm.cs

@@ -40,8 +40,8 @@ namespace QuantConnect.Algorithm.CSharp
         private int _expectedContractIndex;
         private readonly List<Symbol> _expectedContracts = new List<Symbol>
         {
-            SymbolRepresentation.ParseOptionTickerOSI("GOOG  151224P00750000"),
             SymbolRepresentation.ParseOptionTickerOSI("GOOG  151224P00747500"),
+            SymbolRepresentation.ParseOptionTickerOSI("GOOG  151224P00750000"),
             SymbolRepresentation.ParseOptionTickerOSI("GOOG  151224P00752500")
         };
 
@@ -109,6 +109,11 @@ namespace QuantConnect.Algorithm.CSharp
                 var googOptionChain = AddOption(UnderlyingTicker);
                 googOptionChain.SetFilter(u =>
                 {
+                    // we added the universe at 10, the universe selection data should not be from before
+                    if (u.Underlying.EndTime.Hour < 10)
+                    {
+                        throw new Exception($"Unexpected underlying data point {u.Underlying.EndTime} {u.Underlying}");
+                    }
                     // find first put above market price
                     return u.IncludeWeeklys()
                         .Strikes(+1, +1)
@@ -231,7 +236,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Treynor Ratio", "0"},
             {"Total Fees", "$6.00"},
             {"Estimated Strategy Capacity", "$2000.00"},
-            {"Lowest Capacity Asset", "GOOCV 305RBQ2BZBZT2|GOOCV VP83T1ZUHROL"},
+            {"Lowest Capacity Asset", "GOOCV 305RBR0BSWIX2|GOOCV VP83T1ZUHROL"},
             {"Fitness Score", "0"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
@@ -251,7 +256,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "1e7b3e90918777b9dbf46353a96f3329"}
+            {"OrderListHash", "550a99c482106defd8ba15f48183768e"}
         };
     }
 }

Algorithm.CSharp/AddTwoAndRemoveOneOptionContractRegressionAlgorithm.cs

@@ -0,0 +1,150 @@
+/*
+ * 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.
+*/
+
+using System;
+using System.Linq;
+using QuantConnect.Data;
+using QuantConnect.Interfaces;
+using System.Collections.Generic;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Regression algorithm reproducing issue where underlying option contract would be removed with the first call
+    /// too RemoveOptionContract
+    /// </summary>
+    public class AddTwoAndRemoveOneOptionContractRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Symbol _contract1;
+        private Symbol _contract2;
+        private bool _hasRemoved;
+
+        public override void Initialize()
+        {
+            SetStartDate(2014, 06, 06);
+            SetEndDate(2014, 06, 06);
+
+            UniverseSettings.DataNormalizationMode = DataNormalizationMode.Raw;
+            UniverseSettings.MinimumTimeInUniverse = TimeSpan.Zero;
+
+            var aapl = QuantConnect.Symbol.Create("AAPL", SecurityType.Equity, Market.USA);
+
+            var contracts = OptionChainProvider.GetOptionContractList(aapl, Time)
+                .OrderBy(symbol => symbol.ID.Symbol)
+                .Where(optionContract => optionContract.ID.OptionRight == OptionRight.Call
+                    && optionContract.ID.OptionStyle == OptionStyle.American)
+                .Take(2)
+                .ToList();
+
+            _contract1 = contracts[0];
+            _contract2 = contracts[1];
+            AddOptionContract(_contract1);
+            AddOptionContract(_contract2);
+        }
+
+        public override void OnData(Slice slice)
+        {
+            if (slice.HasData)
+            {
+                if (!_hasRemoved)
+                {
+                    RemoveOptionContract(_contract1);
+                    _hasRemoved = true;
+                }
+                else
+                {
+                    var subscriptions =
+                        SubscriptionManager.SubscriptionDataConfigService.GetSubscriptionDataConfigs("AAPL");
+                    if (subscriptions.Count == 0)
+                    {
+                        throw new Exception("No configuration for underlying was found!");
+                    }
+
+                    if (!Portfolio.Invested)
+                    {
+                        Buy(_contract2, 1);
+                    }
+                }
+            }
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            if (!_hasRemoved)
+            {
+                throw new Exception("Expect a single call to OnData where we removed the option and underlying");
+            }
+        }
+
+        /// <summary>
+        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
+        /// </summary>
+        public bool CanRunLocally { get; } = true;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public Language[] Languages { get; } = { Language.CSharp };
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        {
+            {"Total Trades", "2"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "0%"},
+            {"Drawdown", "0%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "0%"},
+            {"Sharpe Ratio", "0"},
+            {"Probabilistic Sharpe Ratio", "0%"},
+            {"Loss Rate", "0%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "0"},
+            {"Beta", "0"},
+            {"Annual Standard Deviation", "0"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "0"},
+            {"Tracking Error", "0"},
+            {"Treynor Ratio", "0"},
+            {"Total Fees", "$2.00"},
+            {"Estimated Strategy Capacity", "$230000.00"},
+            {"Lowest Capacity Asset", "AAPL VXBK4QQIRLZA|AAPL R735QTJ8XC9X"},
+            {"Fitness Score", "0"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "0"},
+            {"Return Over Maximum Drawdown", "0"},
+            {"Portfolio Turnover", "0"},
+            {"Total Insights Generated", "0"},
+            {"Total Insights Closed", "0"},
+            {"Total Insights Analysis Completed", "0"},
+            {"Long Insight Count", "0"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "$0"},
+            {"Total Accumulated Estimated Alpha Value", "$0"},
+            {"Mean Population Estimated Insight Value", "$0"},
+            {"Mean Population Direction", "0%"},
+            {"Mean Population Magnitude", "0%"},
+            {"Rolling Averaged Population Direction", "0%"},
+            {"Rolling Averaged Population Magnitude", "0%"},
+            {"OrderListHash", "228194dcc6fd8689a67f383577ee2d85"}
+        };
+    }
+}

Algorithm.CSharp/AddUniverseSelectionModelAlgorithm.cs

@@ -90,18 +90,18 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "3.300%"},
             {"Expectancy", "-1"},
             {"Net Profit", "-0.168%"},
-            {"Sharpe Ratio", "-0.126"},
-            {"Probabilistic Sharpe Ratio", "45.081%"},
+            {"Sharpe Ratio", "62.513"},
+            {"Probabilistic Sharpe Ratio", "0%"},
             {"Loss Rate", "100%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "-2.896"},
-            {"Beta", "0.551"},
-            {"Annual Standard Deviation", "0.385"},
-            {"Annual Variance", "0.148"},
-            {"Information Ratio", "-13.66"},
-            {"Tracking Error", "0.382"},
-            {"Treynor Ratio", "-0.088"},
+            {"Alpha", "1.118"},
+            {"Beta", "1.19"},
+            {"Annual Standard Deviation", "0.213"},
+            {"Annual Variance", "0.046"},
+            {"Information Ratio", "70.862"},
+            {"Tracking Error", "0.043"},
+            {"Treynor Ratio", "11.209"},
             {"Total Fees", "$23.21"},
             {"Estimated Strategy Capacity", "$340000000.00"},
             {"Lowest Capacity Asset", "FB V6OIPNZEM8V9"},

Algorithm.CSharp/AddUniverseSelectionModelCoarseAlgorithm.cs

@@ -101,18 +101,18 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "5.800%"},
             {"Expectancy", "-0.731"},
             {"Net Profit", "-5.588%"},
-            {"Sharpe Ratio", "-3.272"},
-            {"Probabilistic Sharpe Ratio", "5.825%"},
+            {"Sharpe Ratio", "-3.252"},
+            {"Probabilistic Sharpe Ratio", "5.526%"},
             {"Loss Rate", "86%"},
             {"Win Rate", "14%"},
             {"Profit-Loss Ratio", "0.89"},
-            {"Alpha", "-0.594"},
-            {"Beta", "0.707"},
-            {"Annual Standard Deviation", "0.203"},
-            {"Annual Variance", "0.041"},
-            {"Information Ratio", "-2.929"},
-            {"Tracking Error", "0.193"},
-            {"Treynor Ratio", "-0.942"},
+            {"Alpha", "-0.499"},
+            {"Beta", "1.483"},
+            {"Annual Standard Deviation", "0.196"},
+            {"Annual Variance", "0.039"},
+            {"Information Ratio", "-3.844"},
+            {"Tracking Error", "0.142"},
+            {"Treynor Ratio", "-0.43"},
             {"Total Fees", "$37.25"},
             {"Estimated Strategy Capacity", "$520000000.00"},
             {"Lowest Capacity Asset", "AAPL R735QTJ8XC9X"},

Algorithm.CSharp/AdjustedVolumeRegressionAlgorithm.cs

@@ -30,7 +30,7 @@ namespace QuantConnect.Algorithm.CSharp
     {
         private Symbol _aapl;
         private const string Ticker = "AAPL";
-        private FactorFile _factorFile;
+        private CorporateFactorProvider _factorFile;
         private readonly IEnumerator<decimal> _expectedAdjustedVolume = new List<decimal> { 6164842, 3044047, 3680347, 3468303, 2169943, 2652523,
             1499707, 1518215, 1655219, 1510487 }.GetEnumerator();
         private readonly IEnumerator<decimal> _expectedAdjustedAskSize = new List<decimal> { 215600, 5600, 25200, 8400, 5600, 5600, 2800,
@@ -56,7 +56,7 @@ namespace QuantConnect.Algorithm.CSharp
             factorFileProvider.Initialize(mapFileProvider, dataProvider);
 
 
-            _factorFile = factorFileProvider.Get(_aapl);
+            _factorFile = factorFileProvider.Get(_aapl) as CorporateFactorProvider;
         }
 
         /// <summary>
@@ -83,7 +83,7 @@ namespace QuantConnect.Algorithm.CSharp
                 if (_expectedAdjustedVolume.MoveNext() && _expectedAdjustedVolume.Current != aaplData.Volume)
                 {
                     // Our values don't match lets try and give a reason why
-                    var dayFactor = _factorFile.GetSplitFactor(aaplData.Time);
+                    var dayFactor = _factorFile.GetPriceScale(aaplData.Time, DataNormalizationMode.SplitAdjusted);
                     var probableAdjustedVolume = aaplData.Volume / dayFactor;
 
                     if (_expectedAdjustedVolume.Current == probableAdjustedVolume)
@@ -107,7 +107,7 @@ namespace QuantConnect.Algorithm.CSharp
                 if (_expectedAdjustedAskSize.MoveNext() && _expectedAdjustedAskSize.Current != aaplQuoteData.LastAskSize)
                 {
                     // Our values don't match lets try and give a reason why
-                    var dayFactor = _factorFile.GetSplitFactor(aaplQuoteData.Time);
+                    var dayFactor = _factorFile.GetPriceScale(aaplQuoteData.Time, DataNormalizationMode.SplitAdjusted);
                     var probableAdjustedAskSize = aaplQuoteData.LastAskSize / dayFactor;
 
                     if (_expectedAdjustedAskSize.Current == probableAdjustedAskSize)
@@ -126,7 +126,7 @@ namespace QuantConnect.Algorithm.CSharp
                 if (_expectedAdjustedBidSize.MoveNext() && _expectedAdjustedBidSize.Current != aaplQuoteData.LastBidSize)
                 {
                     // Our values don't match lets try and give a reason why
-                    var dayFactor = _factorFile.GetSplitFactor(aaplQuoteData.Time);
+                    var dayFactor = _factorFile.GetPriceScale(aaplQuoteData.Time, DataNormalizationMode.SplitAdjusted);
                     var probableAdjustedBidSize = aaplQuoteData.LastBidSize / dayFactor;
 
                     if (_expectedAdjustedBidSize.Current == probableAdjustedBidSize)

Algorithm.CSharp/AllShortableSymbolsCoarseSelectionRegressionAlgorithm.cs

@@ -198,18 +198,18 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "0%"},
             {"Expectancy", "0"},
             {"Net Profit", "0.192%"},
-            {"Sharpe Ratio", "31.331"},
-            {"Probabilistic Sharpe Ratio", "88.448%"},
+            {"Sharpe Ratio", "231.673"},
+            {"Probabilistic Sharpe Ratio", "0%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "0.138"},
-            {"Beta", "0.04"},
-            {"Annual Standard Deviation", "0.004"},
+            {"Alpha", "0.163"},
+            {"Beta", "-0.007"},
+            {"Annual Standard Deviation", "0.001"},
             {"Annual Variance", "0"},
-            {"Information Ratio", "4.767"},
-            {"Tracking Error", "0.077"},
-            {"Treynor Ratio", "3.223"},
+            {"Information Ratio", "4.804"},
+            {"Tracking Error", "0.098"},
+            {"Treynor Ratio", "-22.526"},
             {"Total Fees", "$307.50"},
             {"Estimated Strategy Capacity", "$2600000.00"},
             {"Lowest Capacity Asset", "GOOCV VP83T1ZUHROL"},

Algorithm.CSharp/AlphaStreamsBasicTemplateAlgorithm.cs

@@ -13,15 +13,12 @@
  * limitations under the License.
 */
 
-using System.Linq;
-using QuantConnect.Data;
 using QuantConnect.Orders;
 using QuantConnect.Interfaces;
-using QuantConnect.Brokerages;
 using QuantConnect.Securities;
 using System.Collections.Generic;
-using QuantConnect.Data.UniverseSelection;
 using QuantConnect.Data.Custom.AlphaStreams;
+using QuantConnect.Algorithm.Framework.Alphas;
 using QuantConnect.Algorithm.Framework.Execution;
 using QuantConnect.Algorithm.Framework.Portfolio;
 
@@ -32,8 +29,6 @@ namespace QuantConnect.Algorithm.CSharp
     /// </summary>
     public class AlphaStreamsBasicTemplateAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
     {
-        private Dictionary<Symbol, HashSet<Symbol>> _symbolsPerAlpha = new Dictionary<Symbol, HashSet<Symbol>>();
-
         /// <summary>
         /// Initialise the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must initialized.
         /// </summary>
@@ -42,11 +37,11 @@ namespace QuantConnect.Algorithm.CSharp
             SetStartDate(2018, 04, 04);
             SetEndDate(2018, 04, 06);
 
+            SetAlpha(new AlphaStreamAlphaModule());
             SetExecution(new ImmediateExecutionModel());
             Settings.MinimumOrderMarginPortfolioPercentage = 0.01m;
             SetPortfolioConstruction(new EqualWeightingAlphaStreamsPortfolioConstructionModel());
-
-            SetSecurityInitializer(new BrokerageModelSecurityInitializer(new DefaultBrokerageModel(),
+            SetSecurityInitializer(new BrokerageModelSecurityInitializer(BrokerageModel,
                 new FuncSecuritySeeder(GetLastKnownPrices)));
 
             foreach (var alphaId in new [] { "623b06b231eb1cc1aa3643a46", "9fc8ef73792331b11dbd5429a" })
@@ -55,77 +50,11 @@ namespace QuantConnect.Algorithm.CSharp
             }
         }
 
-        /// <summary>
-        /// OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here.
-        /// </summary>
-        /// <param name="data">Slice object keyed by symbol containing the stock data</param>
-        public override void OnData(Slice data)
-        {
-            foreach (var portfolioState in data.Get<AlphaStreamsPortfolioState>().Values)
-            {
-                ProcessPortfolioState(portfolioState);
-            }
-        }
-
         public override void OnOrderEvent(OrderEvent orderEvent)
         {
             Log($"OnOrderEvent: {orderEvent}");
         }
 
-        public override void OnSecuritiesChanged(SecurityChanges changes)
-        {
-            changes.FilterCustomSecurities = false;
-            foreach (var addedSecurity in changes.AddedSecurities)
-            {
-                if (addedSecurity.Symbol.IsCustomDataType<AlphaStreamsPortfolioState>())
-                {
-                    if (!_symbolsPerAlpha.ContainsKey(addedSecurity.Symbol))
-                    {
-                        _symbolsPerAlpha[addedSecurity.Symbol] = new HashSet<Symbol>();
-                    }
-                    // warmup alpha state, adding target securities
-                    ProcessPortfolioState(addedSecurity.Cache.GetData<AlphaStreamsPortfolioState>());
-                }
-            }
-
-            Log($"OnSecuritiesChanged: {changes}");
-        }
-
-        private bool UsedBySomeAlpha(Symbol asset)
-        {
-            return _symbolsPerAlpha.Any(pair => pair.Value.Contains(asset));
-        }
-
-        private void ProcessPortfolioState(AlphaStreamsPortfolioState portfolioState)
-        {
-            if (portfolioState == null)
-            {
-                return;
-            }
-
-            var alphaId = portfolioState.Symbol;
-            if (!_symbolsPerAlpha.TryGetValue(alphaId, out var currentSymbols))
-            {
-                _symbolsPerAlpha[alphaId] = currentSymbols = new HashSet<Symbol>();
-            }
-
-            var newSymbols = new HashSet<Symbol>(currentSymbols.Count);
-            foreach (var symbol in portfolioState.PositionGroups?.SelectMany(positionGroup => positionGroup.Positions).Select(state => state.Symbol) ?? Enumerable.Empty<Symbol>())
-            {
-                // only add it if it's not used by any alpha (already added check)
-                if (newSymbols.Add(symbol) && !UsedBySomeAlpha(symbol))
-                {
-                    AddSecurity(symbol, resolution: UniverseSettings.Resolution, extendedMarketHours: UniverseSettings.ExtendedMarketHours);
-                }
-            }
-            _symbolsPerAlpha[alphaId] = newSymbols;
-
-            foreach (var symbol in currentSymbols.Where(symbol => !UsedBySomeAlpha(symbol)))
-            {
-                RemoveSecurity(symbol);
-            }
-        }
-
         /// <summary>
         /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
         /// </summary>

Algorithm.CSharp/AlphaStreamsDifferentAccountCurrencyBasicTemplateAlgorithm.cs

@@ -58,13 +58,13 @@ namespace QuantConnect.Algorithm.CSharp
             {"Loss Rate", "50%"},
             {"Win Rate", "50%"},
             {"Profit-Loss Ratio", "16.59"},
-            {"Alpha", "0.008"},
-            {"Beta", "1.012"},
+            {"Alpha", "0.006"},
+            {"Beta", "1.011"},
             {"Annual Standard Deviation", "0.343"},
             {"Annual Variance", "0.117"},
-            {"Information Ratio", "-0.57"},
+            {"Information Ratio", "-0.859"},
             {"Tracking Error", "0.004"},
-            {"Treynor Ratio", "-0.831"},
+            {"Treynor Ratio", "-0.832"},
             {"Total Fees", "$2.89"},
             {"Estimated Strategy Capacity", "$8900000000.00"},
             {"Lowest Capacity Asset", "AAPL R735QTJ8XC9X"},

Algorithm.CSharp/AlphaStreamsUniverseSelectionTemplateAlgorithm.cs

@@ -14,9 +14,11 @@
 */
 
 using System;
+using QuantConnect.Interfaces;
 using System.Collections.Generic;
 using QuantConnect.Data.UniverseSelection;
 using QuantConnect.Data.Custom.AlphaStreams;
+using QuantConnect.Algorithm.Framework.Alphas;
 using QuantConnect.Algorithm.Framework.Execution;
 using QuantConnect.Algorithm.Framework.Portfolio;
 using QuantConnect.Algorithm.Framework.Selection;
@@ -26,7 +28,7 @@ namespace QuantConnect.Algorithm.CSharp
     /// <summary>
     /// Example algorithm consuming an alpha streams portfolio state and trading based on it
     /// </summary>
-    public class AlphaStreamsUniverseSelectionTemplateAlgorithm : AlphaStreamsBasicTemplateAlgorithm
+    public class AlphaStreamsUniverseSelectionTemplateAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
     {
         /// <summary>
         /// Initialise the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must initialized.
@@ -36,6 +38,7 @@ namespace QuantConnect.Algorithm.CSharp
             SetStartDate(2018, 04, 04);
             SetEndDate(2018, 04, 06);
 
+            SetAlpha(new AlphaStreamAlphaModule());
             SetExecution(new ImmediateExecutionModel());
             Settings.MinimumOrderMarginPortfolioPercentage = 0.01m;
             SetPortfolioConstruction(new EqualWeightingAlphaStreamsPortfolioConstructionModel());
@@ -65,23 +68,63 @@ namespace QuantConnect.Algorithm.CSharp
             }
         }
 
+        /// <summary>
+        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
+        /// </summary>
+        public bool CanRunLocally { get; } = true;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public Language[] Languages { get; } = { Language.CSharp };
 
         /// <summary>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
         /// </summary>
-        public override Dictionary<string, string> ExpectedStatistics
+        public virtual Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
-            get
-            {
-                var result = base.ExpectedStatistics;
-                result["Compounding Annual Return"] = "-13.200%";
-                result["Information Ratio"] = "2.827";
-                result["Tracking Error"] = "0.248";
-                result["Fitness Score"] = "0.011";
-                result["Return Over Maximum Drawdown"] = "-113.513";
-                result["Portfolio Turnover"] = "0.023";
-                return result;
-            }
-        }
+            {"Total Trades", "2"},
+            {"Average Win", "0%"},
+            {"Average Loss", "-0.12%"},
+            {"Compounding Annual Return", "-13.200%"},
+            {"Drawdown", "0.200%"},
+            {"Expectancy", "-1"},
+            {"Net Profit", "-0.116%"},
+            {"Sharpe Ratio", "0"},
+            {"Probabilistic Sharpe Ratio", "0%"},
+            {"Loss Rate", "100%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "0"},
+            {"Beta", "0"},
+            {"Annual Standard Deviation", "0"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "2.474"},
+            {"Tracking Error", "0.339"},
+            {"Treynor Ratio", "0"},
+            {"Total Fees", "$0.00"},
+            {"Estimated Strategy Capacity", "$83000.00"},
+            {"Lowest Capacity Asset", "BTCUSD XJ"},
+            {"Fitness Score", "0.011"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "79228162514264337593543950335"},
+            {"Return Over Maximum Drawdown", "-113.513"},
+            {"Portfolio Turnover", "0.023"},
+            {"Total Insights Generated", "0"},
+            {"Total Insights Closed", "0"},
+            {"Total Insights Analysis Completed", "0"},
+            {"Long Insight Count", "0"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "$0"},
+            {"Total Accumulated Estimated Alpha Value", "$0"},
+            {"Mean Population Estimated Insight Value", "$0"},
+            {"Mean Population Direction", "0%"},
+            {"Mean Population Magnitude", "0%"},
+            {"Rolling Averaged Population Direction", "0%"},
+            {"Rolling Averaged Population Magnitude", "0%"},
+            {"OrderListHash", "2b94bc50a74caebe06c075cdab1bc6da"}
+        };
     }
 }

Algorithm.CSharp/Alphas/MortgageRateVolatilityAlpha.cs

@@ -1,162 +0,0 @@
-/*
- * 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.
-*/
-using System;
-using System.Linq;
-using QuantConnect.Data;
-using QuantConnect.Indicators;
-using QuantConnect.Orders.Fees;
-using QuantConnect.Data.Custom;
-using System.Collections.Generic;
-using QuantConnect.Algorithm.Framework.Alphas;
-using QuantConnect.Algorithm.Framework.Execution;
-using QuantConnect.Algorithm.Framework.Portfolio;
-using QuantConnect.Algorithm.Framework.Risk;
-using QuantConnect.Algorithm.Framework.Selection;
-
-namespace QuantConnect.Algorithm.CSharp.Alphas
-{
-    ///<summary>
-    /// This Alpha Model uses Wells Fargo 30-year Fixed Rate Mortgage data from Quandl to
-    /// generate Insights about the movement of Real Estate ETFs. Mortgage rates can provide information
-    /// regarding the general price trend of real estate, and ETFs provide good continuous-time instruments
-    /// to measure the impact against. Volatility in mortgage rates tends to put downward pressure on real
-    /// estate prices, whereas stable mortgage rates, regardless of true rate, lead to stable or higher real
-    /// estate prices. This Alpha model seeks to take advantage of this correlation by emitting insights
-    /// based on volatility and rate deviation from its historic mean.
-    ///
-    /// This alpha is part of the Benchmark Alpha Series created by QuantConnect which are open
-    /// sourced so the community and client funds can see an example of an alpha.
-    ///</summary>
-    public class MortgageRateVolatilityAlgorithm : QCAlgorithm
-    {
-        public override void Initialize()
-        {
-            SetStartDate(2017, 1, 1);  //Set Start Date
-            SetCash(100000);             //Set Strategy Cash
-
-            UniverseSettings.Resolution = Resolution.Daily;
-            SetSecurityInitializer(security => security.FeeModel = new ConstantFeeModel(0));
-
-            // Basket of 6 liquid real estate ETFs
-            Func<string, Symbol> toSymbol = x => QuantConnect.Symbol.Create(x, SecurityType.Equity, Market.USA);
-            var realEstateETFs = new[] { "VNQ", "REET", "TAO", "FREL", "SRET", "HIPS" }.Select(toSymbol).ToArray();
-            SetUniverseSelection(new ManualUniverseSelectionModel(realEstateETFs));
-
-            SetAlpha(new MortgageRateVolatilityAlphaModel(this));
-
-            SetPortfolioConstruction(new EqualWeightingPortfolioConstructionModel());
-
-            SetExecution(new ImmediateExecutionModel());
-
-            SetRiskManagement(new NullRiskManagementModel());
-
-        }
-
-        private class MortgageRateVolatilityAlphaModel : AlphaModel
-        {
-            private readonly int _indicatorPeriod;
-            private readonly Resolution _resolution;
-            private readonly TimeSpan _insightDuration;
-            private readonly int _deviations;
-            private readonly double _insightMagnitude;
-            private readonly Symbol _mortgageRate;
-            private readonly SimpleMovingAverage _mortgageRateSma;
-            private readonly StandardDeviation _mortgageRateStd;
-
-            public MortgageRateVolatilityAlphaModel(
-                QCAlgorithm algorithm,
-                int indicatorPeriod = 15,
-                double insightMagnitude = 0.0005,
-                int deviations = 2,
-                Resolution resolution = Resolution.Daily
-                )
-            {
-            	// Add Quandl data for a Well's Fargo 30-year Fixed Rate mortgage
-                _mortgageRate = algorithm.AddData<QuandlMortgagePriceColumns>("WFC/PR_GOV_30YFIXEDVA_APR").Symbol;
-                _indicatorPeriod = indicatorPeriod;
-                _resolution = resolution;
-                _insightDuration = resolution.ToTimeSpan().Multiply(indicatorPeriod);
-                _insightMagnitude = insightMagnitude;
-                _deviations = deviations;
-                
-                // Add indicators for the mortgage rate -- Standard Deviation and Simple Moving Average
-                _mortgageRateStd = algorithm.STD(_mortgageRate, _indicatorPeriod, resolution);
-                _mortgageRateSma = algorithm.SMA(_mortgageRate, _indicatorPeriod, resolution);
-                
-                // Use a history call to warm-up the indicators
-                WarmUpIndicators(algorithm);
-            }
-            
-            public override IEnumerable<Insight> Update(QCAlgorithm algorithm, Slice data)
-            {
-                var insights = new List<Insight>();
-                
-                // Return empty list if data slice doesn't contain monrtgage rate data
-                if (!data.Keys.Contains(_mortgageRate))
-                {
-                    return insights;
-                }
-				// Extract current mortgage rate, the current STD indicator value, and current SMA value
-                var rate = data[_mortgageRate].Value;
-                var deviation = _deviations * _mortgageRateStd;
-                var sma = _mortgageRateSma;
-
-				// Loop through all Active Securities to emit insights
-                foreach (var security in algorithm.ActiveSecurities.Keys)
-                {
-                	// Mortgage rate Symbol will be in the collection, so skip it
-                    if (security == _mortgageRate)
-                    {
-                        return insights;
-                    }
-
-					// If volatility in mortgage rates is high, then we emit an Insight to sell
-                    if ((rate < sma - deviation) || (rate > sma + deviation))
-                    {
-                        insights.Add(Insight.Price(security, _insightDuration, InsightDirection.Down, _insightMagnitude));
-                    }
-                    
-                    // If volatility in mortgage rates is low, then we emit an Insight to buy
-                    if ((rate < sma - (decimal)deviation/2) || (rate > sma + (decimal)deviation/2))
-                    {
-                        insights.Add(Insight.Price(security, _insightDuration, InsightDirection.Up, _insightMagnitude));
-                    }
-                }
-
-                return insights;
-            }
-
-            private void WarmUpIndicators(QCAlgorithm algorithm)
-            {
-            	// Make a history call and update the indicators
-                algorithm.History(new[] { _mortgageRate }, _indicatorPeriod, _resolution).PushThrough(bar =>
-                {
-                    _mortgageRateSma.Update(bar.EndTime, bar.Value);
-                    _mortgageRateStd.Update(bar.EndTime, bar.Value);
-                });
-            }
-        }
-        public class QuandlMortgagePriceColumns : Quandl
-        {
-            public QuandlMortgagePriceColumns()
-            
-            // Rename the Quandl object column to the data we want, which is the 'Value' column
-	        // of the CSV that our API call returns
-                : base(valueColumnName: "Value")
-            {
-            }
-        }
-    }
-}

Algorithm.CSharp/AutoRegressiveIntegratedMovingAverageRegressionAlgorithm.cs

@@ -85,18 +85,18 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "0.100%"},
             {"Expectancy", "3.321"},
             {"Net Profit", "0.089%"},
-            {"Sharpe Ratio", "0.868"},
-            {"Probabilistic Sharpe Ratio", "44.482%"},
+            {"Sharpe Ratio", "0.798"},
+            {"Probabilistic Sharpe Ratio", "40.893%"},
             {"Loss Rate", "24%"},
             {"Win Rate", "76%"},
             {"Profit-Loss Ratio", "4.67"},
-            {"Alpha", "0.001"},
-            {"Beta", "-0"},
+            {"Alpha", "-0.001"},
+            {"Beta", "0.008"},
             {"Annual Standard Deviation", "0.001"},
             {"Annual Variance", "0"},
-            {"Information Ratio", "-2.148"},
-            {"Tracking Error", "0.101"},
-            {"Treynor Ratio", "-4.168"},
+            {"Information Ratio", "-1.961"},
+            {"Tracking Error", "0.092"},
+            {"Treynor Ratio", "0.08"},
             {"Total Fees", "$52.00"},
             {"Estimated Strategy Capacity", "$32000000000.00"},
             {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},

Algorithm.CSharp/AutomaticIndicatorWarmupDataTypeRegressionAlgorithm.cs

@@ -34,7 +34,7 @@ namespace QuantConnect.Algorithm.CSharp
         {
             UniverseSettings.DataNormalizationMode = DataNormalizationMode.Raw;
             EnableAutomaticIndicatorWarmUp = true;
-            SetStartDate(2013, 10, 08);
+            SetStartDate(2013, 10, 07);
             SetEndDate(2013, 10, 09);
 
             var SP500 = QuantConnect.Symbol.Create(Futures.Indices.SP500EMini, SecurityType.Future, Market.CME);
@@ -151,31 +151,31 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "1"},
             {"Average Win", "0%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "-99.999%"},
-            {"Drawdown", "16.100%"},
+            {"Compounding Annual Return", "-100.000%"},
+            {"Drawdown", "19.800%"},
             {"Expectancy", "0"},
-            {"Net Profit", "-6.366%"},
-            {"Sharpe Ratio", "1.194"},
+            {"Net Profit", "-10.353%"},
+            {"Sharpe Ratio", "-1.379"},
             {"Probabilistic Sharpe Ratio", "0%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "5.56"},
-            {"Beta", "-71.105"},
-            {"Annual Standard Deviation", "0.434"},
-            {"Annual Variance", "0.188"},
-            {"Information Ratio", "1.016"},
-            {"Tracking Error", "0.44"},
-            {"Treynor Ratio", "-0.007"},
+            {"Alpha", "3.004"},
+            {"Beta", "5.322"},
+            {"Annual Standard Deviation", "0.725"},
+            {"Annual Variance", "0.525"},
+            {"Information Ratio", "-0.42"},
+            {"Tracking Error", "0.589"},
+            {"Treynor Ratio", "-0.188"},
             {"Total Fees", "$20.35"},
-            {"Estimated Strategy Capacity", "$19000000.00"},
+            {"Estimated Strategy Capacity", "$13000000.00"},
             {"Lowest Capacity Asset", "ES VMKLFZIH2MTD"},
-            {"Fitness Score", "0.138"},
+            {"Fitness Score", "0.125"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "-1.727"},
-            {"Return Over Maximum Drawdown", "-12.061"},
-            {"Portfolio Turnover", "4.916"},
+            {"Sortino Ratio", "-2.162"},
+            {"Return Over Maximum Drawdown", "-8.144"},
+            {"Portfolio Turnover", "3.184"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
             {"Total Insights Analysis Completed", "0"},
@@ -189,7 +189,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "7c841ca58a4385f42236838e5bf0c382"}
+            {"OrderListHash", "7ff48adafe9676f341e64ac9388d3c2c"}
         };
     }
 }

Algorithm.CSharp/BacktestingBrokerageRegressionAlgorithm.cs

@@ -305,18 +305,18 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "0.400%"},
             {"Expectancy", "-1"},
             {"Net Profit", "-0.329%"},
-            {"Sharpe Ratio", "-11.083"},
-            {"Probabilistic Sharpe Ratio", "0%"},
+            {"Sharpe Ratio", "-7.887"},
+            {"Probabilistic Sharpe Ratio", "1.216%"},
             {"Loss Rate", "100%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "-0.003"},
+            {"Alpha", "-0.001"},
             {"Beta", "0.097"},
             {"Annual Standard Deviation", "0.002"},
             {"Annual Variance", "0"},
-            {"Information Ratio", "9.742"},
-            {"Tracking Error", "0.021"},
-            {"Treynor Ratio", "-0.26"},
+            {"Information Ratio", "7.39"},
+            {"Tracking Error", "0.015"},
+            {"Treynor Ratio", "-0.131"},
             {"Total Fees", "$2.00"},
             {"Estimated Strategy Capacity", "$0"},
             {"Lowest Capacity Asset", "GOOCV VP83T1ZUHROL"},
@@ -339,7 +339,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "7f99e1a8ce4675a1e8bbe1ba45967ccd"}
+            {"OrderListHash", "f67306bc706a2cf66288f1cadf6148ed"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateAtreyuAlgorithm.cs

@@ -45,7 +45,7 @@ namespace QuantConnect.Algorithm.CSharp
             {
                 // Can specify the default exchange to execute an order on.
                 // If not specified will default to the primary exchange
-                Exchange = Exchange.NASDAQ,
+                Exchange = Exchange.BATS,
                 // Currently only support order for the day
                 TimeInForce = TimeInForce.Day
             };
@@ -59,7 +59,7 @@ namespace QuantConnect.Algorithm.CSharp
         {
             if (!Portfolio.Invested)
             {
-                // will set 25% of our buying power with a market order that will be routed to exchange set in the default order properties (NASDAQ)
+                // will set 25% of our buying power with a market order that will be routed to exchange set in the default order properties (BATS)
                 SetHoldings("SPY", 0.25m);
                 // will increase our SPY holdings to 50% of our buying power with a market order that will be routed to ARCA
                 SetHoldings("SPY", 0.50m, orderProperties: new AtreyuOrderProperties { Exchange = Exchange.ARCA });
@@ -86,10 +86,10 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "2"},
             {"Average Win", "0%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "93.443%"},
+            {"Compounding Annual Return", "93.340%"},
             {"Drawdown", "1.100%"},
             {"Expectancy", "0"},
-            {"Net Profit", "0.847%"},
+            {"Net Profit", "0.846%"},
             {"Sharpe Ratio", "6.515"},
             {"Probabilistic Sharpe Ratio", "67.535%"},
             {"Loss Rate", "0%"},
@@ -102,14 +102,14 @@ namespace QuantConnect.Algorithm.CSharp
             {"Information Ratio", "6.515"},
             {"Tracking Error", "0.11"},
             {"Treynor Ratio", "0"},
-            {"Total Fees", "$0.52"},
+            {"Total Fees", "$1.20"},
             {"Estimated Strategy Capacity", "$8600000.00"},
             {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
             {"Fitness Score", "0.124"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
             {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "78.376"},
+            {"Return Over Maximum Drawdown", "78.222"},
             {"Portfolio Turnover", "0.124"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
@@ -124,7 +124,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "cb542eaaeab5eac3bcae5d915ded30da"}
+            {"OrderListHash", "01a751a837beafd90015b2fd82edf994"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateContinuousFutureAlgorithm.cs

@@ -0,0 +1,166 @@
+/*
+ * 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.
+*/
+
+using System;
+using QuantConnect.Data;
+using QuantConnect.Orders;
+using QuantConnect.Interfaces;
+using System.Collections.Generic;
+using System.Linq;
+using QuantConnect.Data.UniverseSelection;
+using QuantConnect.Indicators;
+using QuantConnect.Securities;
+using QuantConnect.Securities.Future;
+using Futures = QuantConnect.Securities.Futures;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Basic Continuous Futures Template Algorithm
+    /// </summary>
+    public class BasicTemplateContinuousFutureAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Future _continuousContract;
+        private Security _currentContract;
+        private SimpleMovingAverage _fast;
+        private SimpleMovingAverage _slow;
+
+        /// <summary>
+        /// Initialise the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must initialized.
+        /// </summary>
+        public override void Initialize()
+        {
+            SetStartDate(2013, 7, 1);
+            SetEndDate(2014, 1, 1);
+
+            _continuousContract = AddFuture(Futures.Indices.SP500EMini,
+                dataNormalizationMode: DataNormalizationMode.BackwardsRatio,
+                dataMappingMode: DataMappingMode.LastTradingDay,
+                contractDepthOffset: 0
+            );
+
+            _fast = SMA(_continuousContract.Symbol, 3, Resolution.Daily);
+            _slow = SMA(_continuousContract.Symbol, 10, Resolution.Daily);
+        }
+
+        /// <summary>
+        /// OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here.
+        /// </summary>
+        /// <param name="data">Slice object keyed by symbol containing the stock data</param>
+        public override void OnData(Slice data)
+        {
+            foreach (var changedEvent in data.SymbolChangedEvents.Values)
+            {
+                Debug($"{Time} - SymbolChanged event: {changedEvent}");
+                if (Time.TimeOfDay != TimeSpan.Zero)
+                {
+                    throw new Exception($"{Time} unexpected symbol changed event {changedEvent}!");
+                }
+            }
+
+            if (!Portfolio.Invested)
+            {
+                if(_fast > _slow)
+                {
+                    _currentContract = Securities[_continuousContract.Mapped];
+                    Buy(_currentContract.Symbol, 1);
+                }
+            }
+            else if(_fast < _slow)
+            {
+                Liquidate();
+            }
+
+            if (_currentContract != null && _currentContract.Symbol != _continuousContract.Mapped)
+            {
+                Log($"{Time} - rolling position from {_currentContract.Symbol} to {_continuousContract.Mapped}");
+
+                var currentPositionSize = _currentContract.Holdings.Quantity;
+                Liquidate(_currentContract.Symbol);
+                Buy(_continuousContract.Mapped, currentPositionSize);
+                _currentContract = Securities[_continuousContract.Mapped];
+            }
+        }
+
+        public override void OnOrderEvent(OrderEvent orderEvent)
+        {
+            Debug($"{orderEvent}");
+        }
+
+        public override void OnSecuritiesChanged(SecurityChanges changes)
+        {
+            Debug($"{Time}-{changes}");
+        }
+
+        /// <summary>
+        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
+        /// </summary>
+        public bool CanRunLocally { get; } = true;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public Language[] Languages { get; } = { Language.CSharp, Language.Python };
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        {
+            {"Total Trades", "2"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0.00%"},
+            {"Compounding Annual Return", "-0.007%"},
+            {"Drawdown", "0.000%"},
+            {"Expectancy", "-1"},
+            {"Net Profit", "-0.004%"},
+            {"Sharpe Ratio", "-0.369"},
+            {"Probabilistic Sharpe Ratio", "10.640%"},
+            {"Loss Rate", "100%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "-0"},
+            {"Beta", "0"},
+            {"Annual Standard Deviation", "0"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "-2.751"},
+            {"Tracking Error", "0.082"},
+            {"Treynor Ratio", "-0.616"},
+            {"Total Fees", "$3.70"},
+            {"Estimated Strategy Capacity", "$0"},
+            {"Lowest Capacity Asset", "ES VMKLFZIH2MTD"},
+            {"Fitness Score", "0.007"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "79228162514264337593543950335"},
+            {"Return Over Maximum Drawdown", "-0.738"},
+            {"Portfolio Turnover", "0.01"},
+            {"Total Insights Generated", "0"},
+            {"Total Insights Closed", "0"},
+            {"Total Insights Analysis Completed", "0"},
+            {"Long Insight Count", "0"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "$0"},
+            {"Total Accumulated Estimated Alpha Value", "$0"},
+            {"Mean Population Estimated Insight Value", "$0"},
+            {"Mean Population Direction", "0%"},
+            {"Mean Population Magnitude", "0%"},
+            {"Rolling Averaged Population Direction", "0%"},
+            {"Rolling Averaged Population Magnitude", "0%"},
+            {"OrderListHash", "bd7fbe57802dfedb36c85609b7234016"}
+        };
+    }
+}

Algorithm.CSharp/BasicTemplateDailyAlgorithm.cs

@@ -75,18 +75,18 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "1.200%"},
             {"Expectancy", "0"},
             {"Net Profit", "3.464%"},
-            {"Sharpe Ratio", "9.933"},
-            {"Probabilistic Sharpe Ratio", "82.470%"},
+            {"Sharpe Ratio", "19.148"},
+            {"Probabilistic Sharpe Ratio", "97.754%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "1.957"},
-            {"Beta", "-0.125"},
-            {"Annual Standard Deviation", "0.164"},
-            {"Annual Variance", "0.027"},
-            {"Information Ratio", "-4.577"},
-            {"Tracking Error", "0.225"},
-            {"Treynor Ratio", "-13.006"},
+            {"Alpha", "-0.005"},
+            {"Beta", "0.998"},
+            {"Annual Standard Deviation", "0.138"},
+            {"Annual Variance", "0.019"},
+            {"Information Ratio", "-34.028"},
+            {"Tracking Error", "0"},
+            {"Treynor Ratio", "2.651"},
             {"Total Fees", "$3.45"},
             {"Estimated Strategy Capacity", "$970000000.00"},
             {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},

Algorithm.CSharp/BasicTemplateFuturesAlgorithm.cs

@@ -18,6 +18,7 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using QuantConnect.Data;
+using QuantConnect.Data.UniverseSelection;
 using QuantConnect.Interfaces;
 using QuantConnect.Securities;
 using QuantConnect.Securities.Future;
@@ -64,6 +65,9 @@ namespace QuantConnect.Algorithm.CSharp
 
             var benchmark = AddEquity("SPY");
             SetBenchmark(benchmark.Symbol);
+
+            var seeder = new FuncSecuritySeeder(GetLastKnownPrices);
+            SetSecurityInitializer(security => seeder.SeedSecurity(security));
         }
 
         /// <summary>
@@ -72,6 +76,15 @@ namespace QuantConnect.Algorithm.CSharp
         /// <param name="slice">The current slice of data keyed by symbol string</param>
         public override void OnData(Slice slice)
         {
+            foreach (var changedEvent in slice.SymbolChangedEvents.Values)
+            {
+                Debug($"{Time} - SymbolChanged event: {changedEvent}");
+                if (Time.TimeOfDay != TimeSpan.Zero)
+                {
+                    throw new Exception($"{Time} unexpected symbol changed event {changedEvent}!");
+                }
+            }
+
             if (!Portfolio.Invested)
             {
                 foreach(var chain in slice.FutureChains)
@@ -112,6 +125,19 @@ namespace QuantConnect.Algorithm.CSharp
             var maintenanceIntraday = futureMarginModel.MaintenanceIntradayMarginRequirement;
         }
 
+        public override void OnSecuritiesChanged(SecurityChanges changes)
+        {
+            foreach (var addedSecurity in changes.AddedSecurities)
+            {
+                if (addedSecurity.Symbol.SecurityType == SecurityType.Future
+                    && !addedSecurity.Symbol.IsCanonical()
+                    && !addedSecurity.HasData)
+                {
+                    throw new Exception($"Future contracts did not work up as expected: {addedSecurity.Symbol}");
+                }
+            }
+        }
+
         /// <summary>
         /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
         /// </summary>
@@ -134,18 +160,18 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "13.500%"},
             {"Expectancy", "-0.818"},
             {"Net Profit", "-13.517%"},
-            {"Sharpe Ratio", "-2.678"},
+            {"Sharpe Ratio", "-98.781"},
             {"Probabilistic Sharpe Ratio", "0%"},
             {"Loss Rate", "89%"},
             {"Win Rate", "11%"},
             {"Profit-Loss Ratio", "0.69"},
-            {"Alpha", "4.469"},
-            {"Beta", "-0.961"},
-            {"Annual Standard Deviation", "0.373"},
-            {"Annual Variance", "0.139"},
-            {"Information Ratio", "-13.191"},
-            {"Tracking Error", "0.507"},
-            {"Treynor Ratio", "1.04"},
+            {"Alpha", "-1.676"},
+            {"Beta", "0.042"},
+            {"Annual Standard Deviation", "0.01"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "-73.981"},
+            {"Tracking Error", "0.233"},
+            {"Treynor Ratio", "-23.975"},
             {"Total Fees", "$15207.00"},
             {"Estimated Strategy Capacity", "$8000.00"},
             {"Lowest Capacity Asset", "GC VOFJUCDY9XNH"},

Algorithm.CSharp/BasicTemplateFuturesDailyAlgorithm.cs

@@ -0,0 +1,160 @@
+/*
+ * 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.
+ *
+*/
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using QuantConnect.Data;
+using QuantConnect.Interfaces;
+using QuantConnect.Securities;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// This example demonstrates how to add futures with daily resolution.
+    /// </summary>
+    /// <meta name="tag" content="using data" />
+    /// <meta name="tag" content="benchmarks" />
+    /// <meta name="tag" content="futures" />
+    public class BasicTemplateFuturesDailyAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Symbol _contractSymbol;
+        protected virtual Resolution Resolution => Resolution.Daily;
+
+        // S&P 500 EMini futures
+        private const string RootSP500 = Futures.Indices.SP500EMini;
+
+        // Gold futures
+        private const string RootGold = Futures.Metals.Gold;
+
+        /// <summary>
+        /// Initialize your algorithm and add desired assets.
+        /// </summary>
+        public override void Initialize()
+        {
+            SetStartDate(2013, 10, 08);
+            SetEndDate(2014, 10, 10);
+            SetCash(1000000);
+
+            var futureSP500 = AddFuture(RootSP500, Resolution);
+            var futureGold = AddFuture(RootGold, Resolution);
+
+            // set our expiry filter for this futures chain
+            // SetFilter method accepts TimeSpan objects or integer for days.
+            // The following statements yield the same filtering criteria 
+            futureSP500.SetFilter(TimeSpan.Zero, TimeSpan.FromDays(182));
+            futureGold.SetFilter(0, 182);
+        }
+
+        /// <summary>
+        /// Event - v3.0 DATA EVENT HANDLER: (Pattern) Basic template for user to override for receiving all subscription data in a single event
+        /// </summary>
+        /// <param name="slice">The current slice of data keyed by symbol string</param>
+        public override void OnData(Slice slice)
+        {
+            if (!Portfolio.Invested)
+            {
+                foreach(var chain in slice.FutureChains)
+                {
+                    // find the front contract expiring no earlier than in 90 days
+                    var contract = (
+                        from futuresContract in chain.Value.OrderBy(x => x.Expiry)
+                        where futuresContract.Expiry > Time.Date.AddDays(90)
+                        select futuresContract
+                    ).FirstOrDefault();
+
+                    // if found, trade it
+                    if (contract != null && IsMarketOpen(contract.Symbol))
+                    {
+                        _contractSymbol = contract.Symbol;
+                        MarketOrder(_contractSymbol, 1);
+                    }
+                }
+            }
+            else
+            {
+                Liquidate();
+            }
+
+            foreach (var changedEvent in slice.SymbolChangedEvents.Values)
+            {
+                if (Time.TimeOfDay != TimeSpan.Zero)
+                {
+                    throw new Exception($"{Time} unexpected symbol changed event {changedEvent}!");
+                }
+            }
+        }
+
+        /// <summary>
+        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
+        /// </summary>
+        public virtual bool CanRunLocally { get; } = true;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public virtual Language[] Languages { get; } = { Language.CSharp, Language.Python };
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public virtual Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        {
+            {"Total Trades", "92"},
+            {"Average Win", "0.08%"},
+            {"Average Loss", "-0.01%"},
+            {"Compounding Annual Return", "-0.450%"},
+            {"Drawdown", "0.500%"},
+            {"Expectancy", "-0.824"},
+            {"Net Profit", "-0.453%"},
+            {"Sharpe Ratio", "-1.803"},
+            {"Probabilistic Sharpe Ratio", "0%"},
+            {"Loss Rate", "98%"},
+            {"Win Rate", "2%"},
+            {"Profit-Loss Ratio", "7.09"},
+            {"Alpha", "-0.003"},
+            {"Beta", "-0.001"},
+            {"Annual Standard Deviation", "0.002"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "-1.394"},
+            {"Tracking Error", "0.089"},
+            {"Treynor Ratio", "4.298"},
+            {"Total Fees", "$170.20"},
+            {"Estimated Strategy Capacity", "$36000.00"},
+            {"Lowest Capacity Asset", "ES VP274HSU1AF5"},
+            {"Fitness Score", "0.009"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "-0.8"},
+            {"Return Over Maximum Drawdown", "-0.992"},
+            {"Portfolio Turnover", "0.025"},
+            {"Total Insights Generated", "0"},
+            {"Total Insights Closed", "0"},
+            {"Total Insights Analysis Completed", "0"},
+            {"Long Insight Count", "0"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "$0"},
+            {"Total Accumulated Estimated Alpha Value", "$0"},
+            {"Mean Population Estimated Insight Value", "$0"},
+            {"Mean Population Direction", "0%"},
+            {"Mean Population Magnitude", "0%"},
+            {"Rolling Averaged Population Direction", "0%"},
+            {"Rolling Averaged Population Magnitude", "0%"},
+            {"OrderListHash", "09b2f274fa2385597a803e58b784f675"}
+        };
+    }
+}

Algorithm.CSharp/BasicTemplateFuturesFrameworkAlgorithm.cs

@@ -142,18 +142,18 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "5.000%"},
             {"Expectancy", "0"},
             {"Net Profit", "-3.312%"},
-            {"Sharpe Ratio", "-7.795"},
-            {"Probabilistic Sharpe Ratio", "0.164%"},
+            {"Sharpe Ratio", "-6.305"},
+            {"Probabilistic Sharpe Ratio", "9.342%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "-1.362"},
-            {"Beta", "0.257"},
-            {"Annual Standard Deviation", "0.109"},
-            {"Annual Variance", "0.012"},
-            {"Information Ratio", "-14.947"},
-            {"Tracking Error", "0.19"},
-            {"Treynor Ratio", "-3.309"},
+            {"Alpha", "-1.465"},
+            {"Beta", "0.312"},
+            {"Annual Standard Deviation", "0.134"},
+            {"Annual Variance", "0.018"},
+            {"Information Ratio", "-14.77"},
+            {"Tracking Error", "0.192"},
+            {"Treynor Ratio", "-2.718"},
             {"Total Fees", "$3.70"},
             {"Estimated Strategy Capacity", "$52000000.00"},
             {"Lowest Capacity Asset", "GC VL5E74HP3EE5"},

Algorithm.CSharp/BasicTemplateFuturesHourlyAlgorithm.cs

@@ -0,0 +1,96 @@
+/*
+ * 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.
+ *
+*/
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using QuantConnect.Data;
+using QuantConnect.Interfaces;
+using QuantConnect.Securities;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// This regressions tests the BasicTemplateFuturesDailyAlgorithm with hour data
+    /// </summary>
+    /// <meta name="tag" content="using data" />
+    /// <meta name="tag" content="benchmarks" />
+    /// <meta name="tag" content="futures" />
+    public class BasicTemplateFuturesHourlyAlgorithm : BasicTemplateFuturesDailyAlgorithm
+    {
+        private Symbol _contractSymbol;
+        protected override Resolution Resolution => Resolution.Hour;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
+        /// </summary>
+        public override bool CanRunLocally { get; } = true;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public override Language[] Languages { get; } = { Language.CSharp, Language.Python };
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public override Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        {
+            {"Total Trades", "1988"},
+            {"Average Win", "0.01%"},
+            {"Average Loss", "0.00%"},
+            {"Compounding Annual Return", "-4.120%"},
+            {"Drawdown", "4.200%"},
+            {"Expectancy", "-0.870"},
+            {"Net Profit", "-4.150%"},
+            {"Sharpe Ratio", "-6.061"},
+            {"Probabilistic Sharpe Ratio", "0%"},
+            {"Loss Rate", "97%"},
+            {"Win Rate", "3%"},
+            {"Profit-Loss Ratio", "2.92"},
+            {"Alpha", "-0.027"},
+            {"Beta", "-0.006"},
+            {"Annual Standard Deviation", "0.005"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "-1.66"},
+            {"Tracking Error", "0.089"},
+            {"Treynor Ratio", "4.919"},
+            {"Total Fees", "$3677.80"},
+            {"Estimated Strategy Capacity", "$2000.00"},
+            {"Lowest Capacity Asset", "ES VP274HSU1AF5"},
+            {"Fitness Score", "0.128"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "-6.856"},
+            {"Return Over Maximum Drawdown", "-0.995"},
+            {"Portfolio Turnover", "0.648"},
+            {"Total Insights Generated", "0"},
+            {"Total Insights Closed", "0"},
+            {"Total Insights Analysis Completed", "0"},
+            {"Long Insight Count", "0"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "$0"},
+            {"Total Accumulated Estimated Alpha Value", "$0"},
+            {"Mean Population Estimated Insight Value", "$0"},
+            {"Mean Population Direction", "0%"},
+            {"Mean Population Magnitude", "0%"},
+            {"Rolling Averaged Population Direction", "0%"},
+            {"Rolling Averaged Population Magnitude", "0%"},
+            {"OrderListHash", "87d2b127c9859cad9d2c65ac9d76deb5"}
+        };
+    }
+}

Algorithm.CSharp/BasicTemplateHourlyAlgorithm.cs

@@ -0,0 +1,124 @@
+/*
+ * 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.
+*/
+
+using System.Collections.Generic;
+using QuantConnect.Data;
+using QuantConnect.Interfaces;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Basic template algorithm simply initializes the date range and cash. This is a skeleton
+    /// framework you can use for designing an algorithm.
+    /// </summary>
+    /// <meta name="tag" content="using data" />
+    /// <meta name="tag" content="using quantconnect" />
+    /// <meta name="tag" content="trading and orders" />
+    public class BasicTemplateHourlyAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Symbol _spy = QuantConnect.Symbol.Create("SPY", SecurityType.Equity, Market.USA);
+
+        /// <summary>
+        /// Initialise the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must initialized.
+        /// </summary>
+        public override void Initialize()
+        {
+            SetStartDate(2013, 10, 07);  //Set Start Date
+            SetEndDate(2013, 10, 11);    //Set End Date
+            SetCash(100000);             //Set Strategy Cash
+
+            // Find more symbols here: http://quantconnect.com/data
+            // Forex, CFD, Equities Resolutions: Tick, Second, Minute, Hour, Daily.
+            // Futures Resolution: Tick, Second, Minute
+            // Options Resolution: Minute Only.
+            AddEquity("SPY", Resolution.Hour);
+
+            // There are other assets with similar methods. See "Selecting Options" etc for more details.
+            // AddFuture, AddForex, AddCfd, AddOption
+        }
+
+        /// <summary>
+        /// OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here.
+        /// </summary>
+        /// <param name="data">Slice object keyed by symbol containing the stock data</param>
+        public override void OnData(Slice data)
+        {
+            if (!Portfolio.Invested)
+            {
+                SetHoldings(_spy, 1);
+                Debug("Purchased Stock");
+            }
+        }
+
+        /// <summary>
+        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
+        /// </summary>
+        public bool CanRunLocally { get; } = true;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public Language[] Languages { get; } = { Language.CSharp };
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        {
+            {"Total Trades", "1"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "227.693%"},
+            {"Drawdown", "2.000%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "1.529%"},
+            {"Sharpe Ratio", "8.889"},
+            {"Probabilistic Sharpe Ratio", "67.609%"},
+            {"Loss Rate", "0%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "-0.005"},
+            {"Beta", "0.996"},
+            {"Annual Standard Deviation", "0.222"},
+            {"Annual Variance", "0.049"},
+            {"Information Ratio", "-14.564"},
+            {"Tracking Error", "0.001"},
+            {"Treynor Ratio", "1.978"},
+            {"Total Fees", "$3.44"},
+            {"Estimated Strategy Capacity", "$110000000.00"},
+            {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
+            {"Fitness Score", "0.247"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "12.105"},
+            {"Return Over Maximum Drawdown", "112.047"},
+            {"Portfolio Turnover", "0.249"},
+            {"Total Insights Generated", "0"},
+            {"Total Insights Closed", "0"},
+            {"Total Insights Analysis Completed", "0"},
+            {"Long Insight Count", "0"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "$0"},
+            {"Total Accumulated Estimated Alpha Value", "$0"},
+            {"Mean Population Estimated Insight Value", "$0"},
+            {"Mean Population Direction", "0%"},
+            {"Mean Population Magnitude", "0%"},
+            {"Rolling Averaged Population Direction", "0%"},
+            {"Rolling Averaged Population Magnitude", "0%"},
+            {"OrderListHash", "f409be3a7c63d9c1394c2e6c005a15ee"}
+        };
+    }
+}

Algorithm.CSharp/BasicTemplateIndexAlgorithm.cs

@@ -30,36 +30,39 @@ namespace QuantConnect.Algorithm.CSharp
     /// <meta name="tag" content="indexes" />
     public class BasicTemplateIndexAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
     {
-        private Symbol _spx;
-        private Symbol _spxOption;
+        protected Symbol Spx;
+        protected Symbol SpxOption;
         private ExponentialMovingAverage _emaSlow;
         private ExponentialMovingAverage _emaFast;
+        
+        protected virtual Resolution Resolution => Resolution.Minute;
+        protected virtual int StartDay => 4;
 
         /// <summary>
         /// Initialize your algorithm and add desired assets.
         /// </summary>
         public override void Initialize()
         {
-            SetStartDate(2021, 1, 4);
-            SetEndDate(2021, 1, 15);
+            SetStartDate(2021, 1, StartDay);
+            SetEndDate(2021, 1, 18);
             SetCash(1000000);
 
             // Use indicator for signal; but it cannot be traded
-            _spx = AddIndex("SPX", Resolution.Minute).Symbol;
+            Spx = AddIndex("SPX", Resolution).Symbol;
 
             // Trade on SPX ITM calls
-            _spxOption = QuantConnect.Symbol.CreateOption(
-                _spx,
+            SpxOption = QuantConnect.Symbol.CreateOption(
+                Spx,
                 Market.USA,
                 OptionStyle.European,
                 OptionRight.Call,
                 3200m,
                 new DateTime(2021, 1, 15));
 
-            AddIndexOptionContract(_spxOption, Resolution.Minute);
+            AddIndexOptionContract(SpxOption, Resolution);
 
-            _emaSlow = EMA(_spx, 80);
-            _emaFast = EMA(_spx, 200);
+            _emaSlow = EMA(Spx, 80);
+            _emaFast = EMA(Spx, 200);
         }
 
         /// <summary>
@@ -67,7 +70,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public override void OnData(Slice slice)
         {
-            if (!slice.Bars.ContainsKey(_spx) || !slice.Bars.ContainsKey(_spxOption))
+            if (!slice.Bars.ContainsKey(Spx) || !slice.Bars.ContainsKey(SpxOption))
             {
                 return;
             }
@@ -80,7 +83,7 @@ namespace QuantConnect.Algorithm.CSharp
 
             if (_emaFast > _emaSlow)
             {
-                SetHoldings(_spxOption, 1);
+                SetHoldings(SpxOption, 1);
             }
             else
             {
@@ -90,7 +93,7 @@ namespace QuantConnect.Algorithm.CSharp
 
         public override void OnEndOfAlgorithm()
         {
-            if (Portfolio[_spx].TotalSaleVolume > 0)
+            if (Portfolio[Spx].TotalSaleVolume > 0)
             {
                 throw new Exception("Index is not tradable.");
             }
@@ -99,46 +102,46 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
         /// </summary>
-        public bool CanRunLocally { get; } = true;
+        public virtual bool CanRunLocally { get; } = true;
 
         /// <summary>
         /// This is used by the regression test system to indicate which languages this algorithm is written in.
         /// </summary>
-        public Language[] Languages { get; } = { Language.CSharp, Language.Python };
+        public virtual Language[] Languages { get; } = { Language.CSharp, Language.Python };
 
         /// <summary>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
         /// </summary>
-        public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        public virtual Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
             {"Total Trades", "4"},
             {"Average Win", "0%"},
             {"Average Loss", "-53.10%"},
-            {"Compounding Annual Return", "-96.172%"},
+            {"Compounding Annual Return", "-92.544%"},
             {"Drawdown", "10.100%"},
             {"Expectancy", "-1"},
             {"Net Profit", "-9.915%"},
-            {"Sharpe Ratio", "-4.217"},
-            {"Probabilistic Sharpe Ratio", "0.052%"},
+            {"Sharpe Ratio", "-3.845"},
+            {"Probabilistic Sharpe Ratio", "0.053%"},
             {"Loss Rate", "100%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "-0.908"},
-            {"Beta", "0.468"},
-            {"Annual Standard Deviation", "0.139"},
-            {"Annual Variance", "0.019"},
-            {"Information Ratio", "-9.003"},
-            {"Tracking Error", "0.142"},
-            {"Treynor Ratio", "-1.251"},
+            {"Alpha", "-0.558"},
+            {"Beta", "0.313"},
+            {"Annual Standard Deviation", "0.112"},
+            {"Annual Variance", "0.013"},
+            {"Information Ratio", "-6.652"},
+            {"Tracking Error", "0.125"},
+            {"Treynor Ratio", "-1.379"},
             {"Total Fees", "$0.00"},
-            {"Estimated Strategy Capacity", "$14000000.00"},
+            {"Estimated Strategy Capacity", "$13000000.00"},
             {"Lowest Capacity Asset", "SPX XL80P3GHDZXQ|SPX 31"},
-            {"Fitness Score", "0.044"},
+            {"Fitness Score", "0.039"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "-1.96"},
-            {"Return Over Maximum Drawdown", "-10.171"},
-            {"Portfolio Turnover", "0.34"},
+            {"Sortino Ratio", "-1.763"},
+            {"Return Over Maximum Drawdown", "-9.371"},
+            {"Portfolio Turnover", "0.278"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
             {"Total Insights Analysis Completed", "0"},
@@ -152,7 +155,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "52521ab779446daf4d38a7c9bbbdd893"}
+            {"OrderListHash", "0668385036aba3e95127607dfc2f1a59"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateIndexDailyAlgorithm.cs

@@ -0,0 +1,108 @@
+using System;
+using System.Collections.Generic;
+using QuantConnect.Data;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Regression for running an Index algorithm with Daily data
+    /// </summary>
+    public class BasicTemplateIndexDailyAlgorithm : BasicTemplateIndexAlgorithm
+    {
+        protected override Resolution Resolution => Resolution.Daily;
+        protected override int StartDay => 1;
+
+        // two complete weeks starting from the 5th plus the 18th bar
+        protected virtual int ExpectedBarCount => 2 * 5 + 1;
+        protected int BarCounter = 0;
+        
+        /// <summary>
+        /// Purchase a contract when we are not invested, liquidate otherwise
+        /// </summary>
+        public override void OnData(Slice slice)
+        {
+            if (!Portfolio.Invested)
+            {
+                // SPX Index is not tradable, but we can trade an option
+                MarketOrder(SpxOption, 1);
+            }
+            else
+            {
+                Liquidate();
+            }
+            
+            // Count how many slices we receive with SPX data in it to assert later
+            if (slice.ContainsKey(Spx))
+            {
+                BarCounter++;
+            }
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            if (BarCounter != ExpectedBarCount)
+            {
+                throw new ArgumentException($"Bar Count {BarCounter} is not expected count of {ExpectedBarCount}");
+            }
+        }
+
+        /// <summary>
+        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
+        /// </summary>
+        public override bool CanRunLocally { get; } = true;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public override Language[] Languages { get; } = { Language.CSharp };
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public override Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        {
+            {"Total Trades", "9"},
+            {"Average Win", "0%"},
+            {"Average Loss", "-39.42%"},
+            {"Compounding Annual Return", "394.321%"},
+            {"Drawdown", "0.200%"},
+            {"Expectancy", "-1"},
+            {"Net Profit", "8.219%"},
+            {"Sharpe Ratio", "6.812"},
+            {"Probabilistic Sharpe Ratio", "91.380%"},
+            {"Loss Rate", "100%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "2.236"},
+            {"Beta", "-1.003"},
+            {"Annual Standard Deviation", "0.317"},
+            {"Annual Variance", "0.101"},
+            {"Information Ratio", "5.805"},
+            {"Tracking Error", "0.359"},
+            {"Treynor Ratio", "-2.153"},
+            {"Total Fees", "$0.00"},
+            {"Estimated Strategy Capacity", "$0"},
+            {"Lowest Capacity Asset", "SPX XL80P3GHDZXQ|SPX 31"},
+            {"Fitness Score", "0.027"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "79228162514264337593543950335"},
+            {"Return Over Maximum Drawdown", "1776.081"},
+            {"Portfolio Turnover", "0.027"},
+            {"Total Insights Generated", "0"},
+            {"Total Insights Closed", "0"},
+            {"Total Insights Analysis Completed", "0"},
+            {"Long Insight Count", "0"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "$0"},
+            {"Total Accumulated Estimated Alpha Value", "$0"},
+            {"Mean Population Estimated Insight Value", "$0"},
+            {"Mean Population Direction", "0%"},
+            {"Mean Population Magnitude", "0%"},
+            {"Rolling Averaged Population Direction", "0%"},
+            {"Rolling Averaged Population Magnitude", "0%"},
+            {"OrderListHash", "474e8e0e28ee84c869f8c69ec3efe371"}
+        };
+    }
+}

Algorithm.CSharp/BasicTemplateIndexHourlyAlgorithm.cs

@@ -0,0 +1,72 @@
+using System.Collections.Generic;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Regression for running an Index algorithm with Hourly data
+    /// </summary>
+    public class BasicTemplateIndexHourlyAlgorithm : BasicTemplateIndexDailyAlgorithm
+    {
+        protected override Resolution Resolution => Resolution.Hour;
+        protected override int ExpectedBarCount => base.ExpectedBarCount * 8;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
+        /// </summary>
+        public override bool CanRunLocally { get; } = true;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public override Language[] Languages { get; } = { Language.CSharp };
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public override Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        {
+            {"Total Trades", "70"},
+            {"Average Win", "0%"},
+            {"Average Loss", "-0.23%"},
+            {"Compounding Annual Return", "-34.441%"},
+            {"Drawdown", "2.000%"},
+            {"Expectancy", "-1"},
+            {"Net Profit", "-2.028%"},
+            {"Sharpe Ratio", "-11.139"},
+            {"Probabilistic Sharpe Ratio", "0.000%"},
+            {"Loss Rate", "100%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "-0.269"},
+            {"Beta", "0.086"},
+            {"Annual Standard Deviation", "0.023"},
+            {"Annual Variance", "0.001"},
+            {"Information Ratio", "-3.624"},
+            {"Tracking Error", "0.094"},
+            {"Treynor Ratio", "-3.042"},
+            {"Total Fees", "$0.00"},
+            {"Estimated Strategy Capacity", "$310000.00"},
+            {"Lowest Capacity Asset", "SPX XL80P3GHDZXQ|SPX 31"},
+            {"Fitness Score", "0.002"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "-14.51"},
+            {"Return Over Maximum Drawdown", "-17.213"},
+            {"Portfolio Turnover", "0.299"},
+            {"Total Insights Generated", "0"},
+            {"Total Insights Closed", "0"},
+            {"Total Insights Analysis Completed", "0"},
+            {"Long Insight Count", "0"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "$0"},
+            {"Total Accumulated Estimated Alpha Value", "$0"},
+            {"Mean Population Estimated Insight Value", "$0"},
+            {"Mean Population Direction", "0%"},
+            {"Mean Population Magnitude", "0%"},
+            {"Rolling Averaged Population Direction", "0%"},
+            {"Rolling Averaged Population Magnitude", "0%"},
+            {"OrderListHash", "3eb56c551f20e2ffa1c56c47c5ee6667"}
+        };
+    }
+}

Algorithm.CSharp/BasicTemplateIndexOptionsAlgorithm.cs

@@ -30,20 +30,22 @@ namespace QuantConnect.Algorithm.CSharp
         private Symbol _spx;
         private ExponentialMovingAverage _emaSlow;
         private ExponentialMovingAverage _emaFast;
+        protected virtual Resolution Resolution => Resolution.Minute;
+        protected virtual int StartDay => 4;
 
         /// <summary>
         /// Initialize your algorithm and add desired assets.
         /// </summary>
         public override void Initialize()
         {
-            SetStartDate(2021, 1, 4);
+            SetStartDate(2021, 1, StartDay);
             SetEndDate(2021, 2, 1);
             SetCash(1000000);
 
             // Use indicator for signal; but it cannot be traded.
             // We will instead trade on SPX options
-            _spx = AddIndex("SPX", Resolution.Minute).Symbol;
-            var spxOptions = AddIndexOption(_spx, Resolution.Minute);
+            _spx = AddIndex("SPX", Resolution).Symbol;
+            var spxOptions = AddIndexOption(_spx, Resolution);
             spxOptions.SetFilter(filterFunc => filterFunc.CallsOnly());
 
             _emaSlow = EMA(_spx, 80);
@@ -122,17 +124,17 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
         /// </summary>
-        public bool CanRunLocally { get; } = false;
+        public virtual bool CanRunLocally { get; } = false;
 
         /// <summary>
         /// This is used by the regression test system to indicate which languages this algorithm is written in.
         /// </summary>
-        public Language[] Languages { get; } = { Language.CSharp, Language.Python };
+        public virtual Language[] Languages { get; } = { Language.CSharp, Language.Python };
 
         /// <summary>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
         /// </summary>
-        public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        public virtual Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
             {"Total Trades", "8220"},
             {"Average Win", "0.00%"},

Algorithm.CSharp/BasicTemplateIndexOptionsDailyAlgorithm.cs

@@ -0,0 +1,117 @@
+/*
+ * 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.
+ *
+*/
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using QuantConnect.Data;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Regression for running an IndexOptions algorithm with Daily data
+    /// </summary>
+    public class BasicTemplateIndexOptionsDailyAlgorithm : BasicTemplateIndexOptionsAlgorithm
+    {
+        protected override Resolution Resolution => Resolution.Daily;
+        protected override int StartDay => 1;
+        
+        /// <summary>
+        /// Index EMA Cross trading index options of the index.
+        /// </summary>
+        public override void OnData(Slice slice)
+        {
+            foreach (var chain in slice.OptionChains.Values)
+            {
+                // Select the contract with the lowest AskPrice
+                var contract = chain.Contracts.OrderBy(x => x.Value.AskPrice).FirstOrDefault().Value;
+
+                if (contract == null)
+                {
+                    return;
+                }
+                
+                if (Portfolio.Invested)
+                {
+                    Liquidate();
+                }
+                else
+                {
+                    MarketOrder(contract.Symbol, 1);
+                }
+            }
+        }
+
+        /// <summary>
+        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
+        /// </summary>
+        public override bool CanRunLocally { get; } = true;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public override Language[] Languages { get; } = { Language.CSharp };
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public override Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        {
+            {"Total Trades", "9"},
+            {"Average Win", "0%"},
+            {"Average Loss", "-0.01%"},
+            {"Compounding Annual Return", "-0.091%"},
+            {"Drawdown", "0.000%"},
+            {"Expectancy", "-1"},
+            {"Net Profit", "-0.008%"},
+            {"Sharpe Ratio", "-4.033"},
+            {"Probabilistic Sharpe Ratio", "0.013%"},
+            {"Loss Rate", "100%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "-0.001"},
+            {"Beta", "0"},
+            {"Annual Standard Deviation", "0"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "-0.447"},
+            {"Tracking Error", "0.136"},
+            {"Treynor Ratio", "-4.612"},
+            {"Total Fees", "$0.00"},
+            {"Estimated Strategy Capacity", "$0"},
+            {"Lowest Capacity Asset", "SPX XL80P59H5E6M|SPX 31"},
+            {"Fitness Score", "0"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "-50718.291"},
+            {"Return Over Maximum Drawdown", "-11.386"},
+            {"Portfolio Turnover", "0"},
+            {"Total Insights Generated", "0"},
+            {"Total Insights Closed", "0"},
+            {"Total Insights Analysis Completed", "0"},
+            {"Long Insight Count", "0"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "$0"},
+            {"Total Accumulated Estimated Alpha Value", "$0"},
+            {"Mean Population Estimated Insight Value", "$0"},
+            {"Mean Population Direction", "0%"},
+            {"Mean Population Magnitude", "0%"},
+            {"Rolling Averaged Population Direction", "0%"},
+            {"Rolling Averaged Population Magnitude", "0%"},
+            {"OrderListHash", "5f5df233d68d9115a0d81785de54e71d"}
+        };
+    }
+}

Algorithm.CSharp/BasicTemplateIndexOptionsHourlyAlgorithm.cs

@@ -0,0 +1,87 @@
+/*
+ * 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.
+ *
+*/
+
+using System.Collections.Generic;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Regression for running an IndexOptions algorithm with Hourly data
+    /// </summary>
+    public class BasicTemplateIndexOptionsHourlyAlgorithm : BasicTemplateIndexOptionsDailyAlgorithm
+    {
+        protected override Resolution Resolution => Resolution.Hour;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
+        /// </summary>
+        public override bool CanRunLocally { get; } = true;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public override Language[] Languages { get; } = { Language.CSharp };
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public override Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        {
+            {"Total Trades", "70"},
+            {"Average Win", "0.00%"},
+            {"Average Loss", "0.00%"},
+            {"Compounding Annual Return", "0%"},
+            {"Drawdown", "0.000%"},
+            {"Expectancy", "0.000"},
+            {"Net Profit", "0%"},
+            {"Sharpe Ratio", "0"},
+            {"Probabilistic Sharpe Ratio", "36.504%"},
+            {"Loss Rate", "97%"},
+            {"Win Rate", "3%"},
+            {"Profit-Loss Ratio", "34.00"},
+            {"Alpha", "0"},
+            {"Beta", "-0"},
+            {"Annual Standard Deviation", "0"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "-0.449"},
+            {"Tracking Error", "0.138"},
+            {"Treynor Ratio", "-0"},
+            {"Total Fees", "$0.00"},
+            {"Estimated Strategy Capacity", "$0"},
+            {"Lowest Capacity Asset", "SPX XL80P59H5E6M|SPX 31"},
+            {"Fitness Score", "0"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "79228162514264337593543950335"},
+            {"Return Over Maximum Drawdown", "0"},
+            {"Portfolio Turnover", "0"},
+            {"Total Insights Generated", "0"},
+            {"Total Insights Closed", "0"},
+            {"Total Insights Analysis Completed", "0"},
+            {"Long Insight Count", "0"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "$0"},
+            {"Total Accumulated Estimated Alpha Value", "$0"},
+            {"Mean Population Estimated Insight Value", "$0"},
+            {"Mean Population Direction", "0%"},
+            {"Mean Population Magnitude", "0%"},
+            {"Rolling Averaged Population Direction", "0%"},
+            {"Rolling Averaged Population Magnitude", "0%"},
+            {"OrderListHash", "f21910eb98ceaa39e02020de95354d86"}
+        };
+    }
+}

Algorithm.CSharp/BasicTemplateIndiaAlgorithm.cs

@@ -14,8 +14,9 @@
 */
 
 using QuantConnect.Data;
-using QuantConnect.Orders;
 using System.Collections.Generic;
+using QuantConnect.Interfaces;
+using QuantConnect.Orders;
 
 namespace QuantConnect.Algorithm.CSharp
 {
@@ -26,29 +27,29 @@ namespace QuantConnect.Algorithm.CSharp
     /// <meta name="tag" content="using data" />
     /// <meta name="tag" content="using quantconnect" />
     /// <meta name="tag" content="trading and orders" />
-    public class BasicTemplateIndiaAlgorithm : QCAlgorithm
+    public class BasicTemplateIndiaAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
     {
         /// <summary>
         /// Initialise the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must initialized.
         /// </summary>
         public override void Initialize()
         {
-            SetStartDate(2003, 10, 07);  //Set Start Date
-            SetEndDate(2003, 10, 11);    //Set End Date
-            SetCash(100000);             //Set Strategy Cash
+            SetAccountCurrency("INR");  //Set Account Currency
+            SetStartDate(2019, 1, 23);  //Set Start Date
+            SetEndDate(2019, 10, 31);   //Set End Date
+            SetCash(100000);            //Set Strategy Cash
 
             // Find more symbols here: http://quantconnect.com/data
             // Equities Resolutions: Tick, Second, Minute, Hour, Daily.
-            AddEquity("UNIONBANK", Resolution.Second, Market.India);
-            
+            AddEquity("YESBANK", Resolution.Minute, Market.India);
+
             //Set Order Prperties as per the requirements for order placement
-            DefaultOrderProperties = new ZerodhaOrderProperties(exchange: Exchange.NSE);
+            DefaultOrderProperties = new IndiaOrderProperties(exchange: Exchange.NSE);
             //override default productType value set in config.json if needed - order specific productType value
-            //DefaultOrderProperties = new ZerodhaOrderProperties(exchange: "nse",ZerodhaOrderProperties.KiteProductType.CNC);
+            //DefaultOrderProperties = new IndiaOrderProperties(exchange: Exchange.NSE, IndiaOrderProperties.IndiaProductType.CNC);
 
             // General Debug statement for acknowledgement
             Debug("Intialization Done");
-
         }
 
         /// <summary>
@@ -59,11 +60,10 @@ namespace QuantConnect.Algorithm.CSharp
         {
             if (!Portfolio.Invested)
             {
-                var marketTicket = MarketOrder("UNIONBANK", 1);
+                var marketTicket = MarketOrder("YESBANK", 1);
             }
         }
 
-    
         public override void OnOrderEvent(OrderEvent orderEvent)
         {
             if (orderEvent.Status.IsFill())
@@ -75,60 +75,60 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
         /// </summary>
-        public bool CanRunLocally { get; } = false;
+        public bool CanRunLocally { get; } = true;
 
         /// <summary>
         /// This is used by the regression test system to indicate which languages this algorithm is written in.
         /// </summary>
-        public Language[] Languages { get; } = { Language.CSharp };
+        public Language[] Languages { get; } = { Language.CSharp, Language.Python };
 
         /// <summary>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
         /// </summary>
         public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
-            {"Total Trades", "3"},
+            {"Total Trades", "1"},
             {"Average Win", "0%"},
-            {"Average Loss", "-1.01%"},
-            {"Compounding Annual Return", "261.134%"},
-            {"Drawdown", "2.200%"},
-            {"Expectancy", "-1"},
-            {"Net Profit", "1.655%"},
-            {"Sharpe Ratio", "8.505"},
-            {"Probabilistic Sharpe Ratio", "66.840%"},
-            {"Loss Rate", "100%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "-0.010%"},
+            {"Drawdown", "0.000%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "-0.008%"},
+            {"Sharpe Ratio", "-1.183"},
+            {"Probabilistic Sharpe Ratio", "0.001%"},
+            {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "-0.091"},
-            {"Beta", "1.006"},
-            {"Annual Standard Deviation", "0.224"},
-            {"Annual Variance", "0.05"},
-            {"Information Ratio", "-33.445"},
-            {"Tracking Error", "0.002"},
-            {"Treynor Ratio", "1.893"},
-            {"Total Fees", "$10.32"},
-            {"Estimated Strategy Capacity", "$27000000.00"},
-            {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
-            {"Fitness Score", "0.747"},
-            {"Kelly Criterion Estimate", "38.796"},
-            {"Kelly Criterion Probability Value", "0.228"},
-            {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "85.095"},
-            {"Portfolio Turnover", "0.747"},
-            {"Total Insights Generated", "100"},
-            {"Total Insights Closed", "99"},
-            {"Total Insights Analysis Completed", "99"},
-            {"Long Insight Count", "100"},
+            {"Alpha", "0"},
+            {"Beta", "0"},
+            {"Annual Standard Deviation", "0"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "-1.183"},
+            {"Tracking Error", "0"},
+            {"Treynor Ratio", "0"},
+            {"Total Fees", "$6.00"},
+            {"Estimated Strategy Capacity", "$61000000000.00"},
+            {"Lowest Capacity Asset", "YESBANK UL"},
+            {"Fitness Score", "0"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "-0.247"},
+            {"Return Over Maximum Drawdown", "-1.104"},
+            {"Portfolio Turnover", "0"},
+            {"Total Insights Generated", "0"},
+            {"Total Insights Closed", "0"},
+            {"Total Insights Analysis Completed", "0"},
+            {"Long Insight Count", "0"},
             {"Short Insight Count", "0"},
             {"Long/Short Ratio", "100%"},
-            {"Estimated Monthly Alpha Value", "$135639.1761"},
-            {"Total Accumulated Estimated Alpha Value", "$21852.9784"},
-            {"Mean Population Estimated Insight Value", "$220.7372"},
-            {"Mean Population Direction", "53.5354%"},
-            {"Mean Population Magnitude", "53.5354%"},
-            {"Rolling Averaged Population Direction", "58.2788%"},
-            {"Rolling Averaged Population Magnitude", "58.2788%"},
-            {"OrderListHash", "ad2216297c759d8e5aef48ff065f8919"}
+            {"Estimated Monthly Alpha Value", "₹0"},
+            {"Total Accumulated Estimated Alpha Value", "₹0"},
+            {"Mean Population Estimated Insight Value", "₹0"},
+            {"Mean Population Direction", "0%"},
+            {"Mean Population Magnitude", "0%"},
+            {"Rolling Averaged Population Direction", "0%"},
+            {"Rolling Averaged Population Magnitude", "0%"},
+            {"OrderListHash", "6cc69218edd7bd461678b9ee0c575db5"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateIndiaIndexAlgorithm.cs

@@ -0,0 +1,158 @@
+/*
+ * 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.
+ *
+*/
+
+using System;
+using QuantConnect.Data;
+using System.Collections.Generic;
+using QuantConnect.Indicators;
+using QuantConnect.Interfaces;
+using QuantConnect.Orders;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// This example demonstrates how to add index asset types.
+    /// </summary>
+    /// <meta name="tag" content="using data" />
+    /// <meta name="tag" content="benchmarks" />
+    /// <meta name="tag" content="indexes" />
+    public class BasicTemplateIndiaIndexAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        protected Symbol Nifty;
+        protected Symbol NiftyETF;
+        private ExponentialMovingAverage _emaSlow;
+        private ExponentialMovingAverage _emaFast;
+
+        /// <summary>
+        /// Initialize your algorithm and add desired assets.
+        /// </summary>
+        public override void Initialize()
+        {
+            SetAccountCurrency("INR"); //Set Account Currency
+            SetStartDate(2019, 1, 1);  //Set End Date
+            SetEndDate(2019, 1, 5);    //Set End Date
+            SetCash(1000000);          //Set Strategy Cash
+
+            // Use indicator for signal; but it cannot be traded
+            Nifty = AddIndex("NIFTY50", Resolution.Minute, Market.India).Symbol;
+
+            //Trade Index based ETF
+            NiftyETF = AddEquity("JUNIORBEES", Resolution.Minute, Market.India).Symbol;
+
+            //Set Order Prperties as per the requirements for order placement
+            DefaultOrderProperties = new IndiaOrderProperties(exchange: Exchange.NSE);
+
+            _emaSlow = EMA(Nifty, 80);
+            _emaFast = EMA(Nifty, 200);
+        }
+
+        /// <summary>
+        /// Index EMA Cross trading underlying.
+        /// </summary>
+        public override void OnData(Slice slice)
+        {
+            if (!slice.Bars.ContainsKey(Nifty) || !slice.Bars.ContainsKey(NiftyETF))
+            {
+                return;
+            }
+
+            // Warm up indicators
+            if (!_emaSlow.IsReady)
+            {
+                return;
+            }
+
+            if (_emaFast > _emaSlow)
+            {
+                if (!Portfolio.Invested)
+                {
+                    var marketTicket = MarketOrder(NiftyETF, 1);
+                }
+            }
+            else
+            {
+                Liquidate();
+            }
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            if (Portfolio[Nifty].TotalSaleVolume > 0)
+            {
+                throw new Exception("Index is not tradable.");
+            }
+        }
+
+        /// <summary>
+        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
+        /// </summary>
+        public virtual bool CanRunLocally { get; } = true;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public virtual Language[] Languages { get; } = { Language.CSharp, Language.Python };
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public virtual Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        {
+            {"Total Trades", "6"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0.00%"},
+            {"Compounding Annual Return", "-0.395%"},
+            {"Drawdown", "0.000%"},
+            {"Expectancy", "-1"},
+            {"Net Profit", "-0.004%"},
+            {"Sharpe Ratio", "-23.595"},
+            {"Probabilistic Sharpe Ratio", "0%"},
+            {"Loss Rate", "100%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "0"},
+            {"Beta", "0"},
+            {"Annual Standard Deviation", "0"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "-23.595"},
+            {"Tracking Error", "0"},
+            {"Treynor Ratio", "0"},
+            {"Total Fees", "$36.00"},
+            {"Estimated Strategy Capacity", "$74000.00"},
+            {"Lowest Capacity Asset", "JUNIORBEES UL"},
+            {"Fitness Score", "0"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "-29.6"},
+            {"Return Over Maximum Drawdown", "-123.624"},
+            {"Portfolio Turnover", "0"},
+            {"Total Insights Generated", "0"},
+            {"Total Insights Closed", "0"},
+            {"Total Insights Analysis Completed", "0"},
+            {"Long Insight Count", "0"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "₹0"},
+            {"Total Accumulated Estimated Alpha Value", "₹0"},
+            {"Mean Population Estimated Insight Value", "₹0"},
+            {"Mean Population Direction", "0%"},
+            {"Mean Population Magnitude", "0%"},
+            {"Rolling Averaged Population Direction", "0%"},
+            {"Rolling Averaged Population Magnitude", "0%"},
+            {"OrderListHash", "4637f26543287548b28a3c296db055d3"}
+        };
+    }
+}

Algorithm.CSharp/BasicTemplateIntrinioEconomicData.cs

@@ -41,7 +41,7 @@ namespace QuantConnect.Algorithm.CSharp
         private readonly Identity _brent = new Identity("Brent");
         private readonly Identity _wti = new Identity("WTI");
 
-        private CompositeIndicator<IndicatorDataPoint> _spread;
+        private CompositeIndicator _spread;
 
         private ExponentialMovingAverage _emaWti;
 

Algorithm.CSharp/BasicTemplateOptionsDailyAlgorithm.cs

@@ -0,0 +1,171 @@
+/*
+ * 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.
+ *
+*/
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using QuantConnect.Data;
+using QuantConnect.Data.Market;
+using QuantConnect.Orders;
+using QuantConnect.Interfaces;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// This example demonstrates how to add options for a given underlying equity security.
+    /// It also shows how you can prefilter contracts easily based on strikes and expirations, and how you
+    /// can inspect the option chain to pick a specific option contract to trade.
+    /// </summary>
+    /// <meta name="tag" content="using data" />
+    /// <meta name="tag" content="options" />
+    /// <meta name="tag" content="filter selection" />
+    public class BasicTemplateOptionsDailyAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private const string UnderlyingTicker = "GOOG";
+        public Symbol OptionSymbol;
+        private bool _optionExpired;
+
+        public override void Initialize()
+        {
+            SetStartDate(2015, 12, 23);
+            SetEndDate(2016, 1, 20);
+            SetCash(100000);
+
+            var equity = AddEquity(UnderlyingTicker, Resolution.Daily);
+            var option = AddOption(UnderlyingTicker, Resolution.Daily);
+            OptionSymbol = option.Symbol;
+
+            option.SetFilter(x => x.CallsOnly().Strikes(0, 1).Expiration(0, 30));
+
+            // use the underlying equity as the benchmark
+            SetBenchmark(equity.Symbol);
+        }
+
+        /// <summary>
+        /// Event - v3.0 DATA EVENT HANDLER: (Pattern) Basic template for user to override for receiving all subscription data in a single event
+        /// </summary>
+        /// <param name="slice">The current slice of data keyed by symbol string</param>
+        public override void OnData(Slice slice)
+        {
+            if (!Portfolio.Invested)
+            {
+                OptionChain chain;
+                if (slice.OptionChains.TryGetValue(OptionSymbol, out chain))
+                {
+                    // Grab us the contract nearest expiry that is not today
+                    var contractsByExpiration = chain.Where(x => x.Expiry != Time.Date).OrderBy(x => x.Expiry);
+                    var contract = contractsByExpiration.FirstOrDefault();
+
+                    if (contract != null && IsMarketOpen(contract.Symbol))
+                    {
+                        // if found, trade it
+                        MarketOrder(contract.Symbol, 1);
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Order fill event handler. On an order fill update the resulting information is passed to this method.
+        /// </summary>
+        /// <param name="orderEvent">Order event details containing details of the evemts</param>
+        /// <remarks>This method can be called asynchronously and so should only be used by seasoned C# experts. Ensure you use proper locks on thread-unsafe objects</remarks>
+        public override void OnOrderEvent(OrderEvent orderEvent)
+        {
+            Log(orderEvent.ToString());
+
+            // Check for our expected OTM option expiry
+            if (orderEvent.Message == "OTM")
+            {
+                // Assert it is at midnight (5AM UTC)
+                if (orderEvent.UtcTime != new DateTime(2016, 1, 16, 5, 0, 0))
+                {
+                    throw new ArgumentException($"Expiry event was not at the correct time, {orderEvent.UtcTime}");
+                }
+
+                _optionExpired = true;
+            }
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            // Assert we had our option expire and fill a liquidation order
+            if (_optionExpired != true)
+            {
+                throw new ArgumentException("Algorithm did not process the option expiration like expected");
+            }
+        }
+
+        /// <summary>
+        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
+        /// </summary>
+        public bool CanRunLocally { get; } = true;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public Language[] Languages { get; } = { Language.CSharp, Language.Python };
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        {
+            {"Total Trades", "2"},
+            {"Average Win", "0%"},
+            {"Average Loss", "-1.31%"},
+            {"Compounding Annual Return", "-15.304%"},
+            {"Drawdown", "1.300%"},
+            {"Expectancy", "-1"},
+            {"Net Profit", "-1.311%"},
+            {"Sharpe Ratio", "-3.31"},
+            {"Probabilistic Sharpe Ratio", "0.035%"},
+            {"Loss Rate", "100%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "0"},
+            {"Beta", "0"},
+            {"Annual Standard Deviation", "0.034"},
+            {"Annual Variance", "0.001"},
+            {"Information Ratio", "-3.31"},
+            {"Tracking Error", "0.034"},
+            {"Treynor Ratio", "0"},
+            {"Total Fees", "$1.00"},
+            {"Estimated Strategy Capacity", "$18000.00"},
+            {"Lowest Capacity Asset", "GOOCV W78ZFMML01JA|GOOCV VP83T1ZUHROL"},
+            {"Fitness Score", "0"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "-1.496"},
+            {"Return Over Maximum Drawdown", "-11.673"},
+            {"Portfolio Turnover", "0"},
+            {"Total Insights Generated", "0"},
+            {"Total Insights Closed", "0"},
+            {"Total Insights Analysis Completed", "0"},
+            {"Long Insight Count", "0"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "$0"},
+            {"Total Accumulated Estimated Alpha Value", "$0"},
+            {"Mean Population Estimated Insight Value", "$0"},
+            {"Mean Population Direction", "0%"},
+            {"Mean Population Magnitude", "0%"},
+            {"Rolling Averaged Population Direction", "0%"},
+            {"Rolling Averaged Population Magnitude", "0%"},
+            {"OrderListHash", "c6d089f1fb86379c74a7413a9c2f8553"}
+        };
+    }
+}

Algorithm.CSharp/BasicTemplateOptionsFilterUniverseAlgorithm.cs

@@ -41,7 +41,7 @@ namespace QuantConnect.Algorithm.CSharp
         public override void Initialize()
         {
             SetStartDate(2015, 12, 24);
-            SetEndDate(2015, 12, 24);
+            SetEndDate(2015, 12, 28);
             SetCash(100000);
 
             var equity = AddEquity(UnderlyingTicker);
@@ -104,14 +104,14 @@ namespace QuantConnect.Algorithm.CSharp
         {
             {"Total Trades", "2"},
             {"Average Win", "0%"},
-            {"Average Loss", "0%"},
-            {"Compounding Annual Return", "0%"},
-            {"Drawdown", "0%"},
-            {"Expectancy", "0"},
-            {"Net Profit", "0%"},
+            {"Average Loss", "-0.40%"},
+            {"Compounding Annual Return", "-21.622%"},
+            {"Drawdown", "0.300%"},
+            {"Expectancy", "-1"},
+            {"Net Profit", "-0.311%"},
             {"Sharpe Ratio", "0"},
             {"Probabilistic Sharpe Ratio", "0%"},
-            {"Loss Rate", "0%"},
+            {"Loss Rate", "100%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
             {"Alpha", "0"},
@@ -124,12 +124,12 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Fees", "$1.00"},
             {"Estimated Strategy Capacity", "$0"},
             {"Lowest Capacity Asset", "GOOCV VP83T1ZUHROL"},
-            {"Fitness Score", "0"},
+            {"Fitness Score", "0.188"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "0"},
-            {"Return Over Maximum Drawdown", "0"},
-            {"Portfolio Turnover", "0"},
+            {"Sortino Ratio", "79228162514264337593543950335"},
+            {"Return Over Maximum Drawdown", "-73.268"},
+            {"Portfolio Turnover", "0.376"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
             {"Total Insights Analysis Completed", "0"},
@@ -143,7 +143,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "92d8a50efe230524512404dab66b19dd"}
+            {"OrderListHash", "452e7a36e0a95e33d3457a908add3ead"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateOptionsFrameworkAlgorithm.cs

@@ -36,7 +36,7 @@ namespace QuantConnect.Algorithm.CSharp
             UniverseSettings.Resolution = Resolution.Minute;
 
             SetStartDate(2014, 06, 05);
-            SetEndDate(2014, 06, 06);
+            SetEndDate(2014, 06, 09);
             SetCash(100000);
 
             // set framework models
@@ -142,47 +142,47 @@ namespace QuantConnect.Algorithm.CSharp
         public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
             {"Total Trades", "4"},
-            {"Average Win", "0%"},
-            {"Average Loss", "0%"},
+            {"Average Win", "0.14%"},
+            {"Average Loss", "-0.28%"},
             {"Compounding Annual Return", "0%"},
-            {"Drawdown", "0%"},
-            {"Expectancy", "0"},
-            {"Net Profit", "0%"},
-            {"Sharpe Ratio", "0"},
-            {"Probabilistic Sharpe Ratio", "0%"},
-            {"Loss Rate", "0%"},
-            {"Win Rate", "0%"},
-            {"Profit-Loss Ratio", "0"},
-            {"Alpha", "0"},
-            {"Beta", "0"},
-            {"Annual Standard Deviation", "0"},
-            {"Annual Variance", "0"},
-            {"Information Ratio", "0"},
-            {"Tracking Error", "0"},
-            {"Treynor Ratio", "0"},
+            {"Drawdown", "385.400%"},
+            {"Expectancy", "-0.249"},
+            {"Net Profit", "-386.489%"},
+            {"Sharpe Ratio", "-0.033"},
+            {"Probabilistic Sharpe Ratio", "1.235%"},
+            {"Loss Rate", "50%"},
+            {"Win Rate", "50%"},
+            {"Profit-Loss Ratio", "0.50"},
+            {"Alpha", "-95.983"},
+            {"Beta", "263.726"},
+            {"Annual Standard Deviation", "30.617"},
+            {"Annual Variance", "937.371"},
+            {"Information Ratio", "-0.044"},
+            {"Tracking Error", "30.604"},
+            {"Treynor Ratio", "-0.004"},
             {"Total Fees", "$3.00"},
-            {"Estimated Strategy Capacity", "$74000.00"},
-            {"Lowest Capacity Asset", "AAPL 2ZQGWTSSZ0WLI|AAPL R735QTJ8XC9X"},
-            {"Fitness Score", "0"},
+            {"Estimated Strategy Capacity", "$0"},
+            {"Lowest Capacity Asset", "AAPL R735QTJ8XC9X"},
+            {"Fitness Score", "0.168"},
             {"Kelly Criterion Estimate", "0.327"},
             {"Kelly Criterion Probability Value", "1"},
             {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "79228162514264337593543950335"},
-            {"Portfolio Turnover", "0"},
-            {"Total Insights Generated", "26"},
+            {"Return Over Maximum Drawdown", "0"},
+            {"Portfolio Turnover", "0.224"},
+            {"Total Insights Generated", "28"},
             {"Total Insights Closed", "24"},
             {"Total Insights Analysis Completed", "24"},
-            {"Long Insight Count", "26"},
+            {"Long Insight Count", "28"},
             {"Short Insight Count", "0"},
             {"Long/Short Ratio", "100%"},
-            {"Estimated Monthly Alpha Value", "$31.01809"},
+            {"Estimated Monthly Alpha Value", "$13.64796"},
             {"Total Accumulated Estimated Alpha Value", "$1.89555"},
             {"Mean Population Estimated Insight Value", "$0.07898125"},
             {"Mean Population Direction", "50%"},
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "50.0482%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "ce06ddfa4b2ffeb666a8910ac8836992"}
+            {"OrderListHash", "87603bd45898dd9c456745fa51f989a5"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateOptionsHourlyAlgorithm.cs

@@ -0,0 +1,158 @@
+/*
+ * 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.
+ *
+*/
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using QuantConnect.Data;
+using QuantConnect.Data.Market;
+using QuantConnect.Orders;
+using QuantConnect.Interfaces;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// This example demonstrates how to add options for a given underlying equity security.
+    /// It also shows how you can prefilter contracts easily based on strikes and expirations, and how you
+    /// can inspect the option chain to pick a specific option contract to trade.
+    /// </summary>
+    /// <meta name="tag" content="using data" />
+    /// <meta name="tag" content="options" />
+    /// <meta name="tag" content="filter selection" />
+    public class BasicTemplateOptionsHourlyAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private const string UnderlyingTicker = "AAPL";
+        public Symbol OptionSymbol;
+
+        public override void Initialize()
+        {
+            SetStartDate(2014, 6, 6);
+            SetEndDate(2014, 6, 9);
+            SetCash(100000);
+
+            var equity = AddEquity(UnderlyingTicker, Resolution.Hour);
+            var option = AddOption(UnderlyingTicker, Resolution.Hour);
+            OptionSymbol = option.Symbol;
+
+            // set our strike/expiry filter for this option chain
+            option.SetFilter(u => u.Strikes(-2, +2)
+                                   // Expiration method accepts TimeSpan objects or integer for days.
+                                   // The following statements yield the same filtering criteria
+                                   .Expiration(0, 180));
+            // .Expiration(TimeSpan.Zero, TimeSpan.FromDays(180)));
+
+            // use the underlying equity as the benchmark
+            SetBenchmark(equity.Symbol);
+        }
+
+        /// <summary>
+        /// Event - v3.0 DATA EVENT HANDLER: (Pattern) Basic template for user to override for receiving all subscription data in a single event
+        /// </summary>
+        /// <param name="slice">The current slice of data keyed by symbol string</param>
+        public override void OnData(Slice slice)
+        {
+            if (!Portfolio.Invested && IsMarketOpen(OptionSymbol))
+            {
+                OptionChain chain;
+                if (slice.OptionChains.TryGetValue(OptionSymbol, out chain))
+                {
+                    // we find at the money (ATM) put contract with farthest expiration
+                    var atmContract = chain
+                        .OrderByDescending(x => x.Expiry)
+                        .ThenBy(x => Math.Abs(chain.Underlying.Price - x.Strike))
+                        .ThenByDescending(x => x.Right)
+                        .FirstOrDefault();
+
+                    if (atmContract != null && IsMarketOpen(atmContract.Symbol))
+                    {
+                        // if found, trade it
+                        MarketOrder(atmContract.Symbol, 1);
+                        MarketOnCloseOrder(atmContract.Symbol, -1);
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Order fill event handler. On an order fill update the resulting information is passed to this method.
+        /// </summary>
+        /// <param name="orderEvent">Order event details containing details of the evemts</param>
+        /// <remarks>This method can be called asynchronously and so should only be used by seasoned C# experts. Ensure you use proper locks on thread-unsafe objects</remarks>
+        public override void OnOrderEvent(OrderEvent orderEvent)
+        {
+            Log(orderEvent.ToString());
+        }
+
+        /// <summary>
+        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
+        /// </summary>
+        public bool CanRunLocally { get; } = true;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public Language[] Languages { get; } = { Language.CSharp, Language.Python };
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        {
+            {"Total Trades", "4"},
+            {"Average Win", "0%"},
+            {"Average Loss", "-0.07%"},
+            {"Compounding Annual Return", "-12.496%"},
+            {"Drawdown", "0.200%"},
+            {"Expectancy", "-1"},
+            {"Net Profit", "-0.134%"},
+            {"Sharpe Ratio", "-8.839"},
+            {"Probabilistic Sharpe Ratio", "0%"},
+            {"Loss Rate", "100%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "0.083"},
+            {"Beta", "-0.054"},
+            {"Annual Standard Deviation", "0.008"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "-18.699"},
+            {"Tracking Error", "0.155"},
+            {"Treynor Ratio", "1.296"},
+            {"Total Fees", "$4.00"},
+            {"Estimated Strategy Capacity", "$1000.00"},
+            {"Lowest Capacity Asset", "AAPL 2ZTXYMUAHCIAU|AAPL R735QTJ8XC9X"},
+            {"Fitness Score", "0.04"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "79228162514264337593543950335"},
+            {"Return Over Maximum Drawdown", "-118.28"},
+            {"Portfolio Turnover", "0.081"},
+            {"Total Insights Generated", "0"},
+            {"Total Insights Closed", "0"},
+            {"Total Insights Analysis Completed", "0"},
+            {"Long Insight Count", "0"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "$0"},
+            {"Total Accumulated Estimated Alpha Value", "$0"},
+            {"Mean Population Estimated Insight Value", "$0"},
+            {"Mean Population Direction", "0%"},
+            {"Mean Population Magnitude", "0%"},
+            {"Rolling Averaged Population Direction", "0%"},
+            {"Rolling Averaged Population Magnitude", "0%"},
+            {"OrderListHash", "81e8a822d43de2165c1d3f52964ec312"}
+        };
+    }
+}

Algorithm.CSharp/BinanceCashAccountFeeRegressionAlgorithm.cs

@@ -0,0 +1,85 @@
+/*
+ * 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.
+*/
+
+using QuantConnect.Brokerages;
+using System.Collections.Generic;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Binance cash account regression algorithm, reproduces issue https://github.com/QuantConnect/Lean/issues/6123
+    /// </summary>
+    public class BinanceCashAccountFeeRegressionAlgorithm : CryptoCashAccountFeeRegressionAlgorithm
+    {
+        public override void Initialize()
+        {
+            SetAccountCurrency("USDT");
+            SetStartDate(2018, 05, 02);
+            SetEndDate(2018, 05, 03);
+            BrokerageName = BrokerageName.Binance;
+            Pair = "BTCUSDT";
+            base.Initialize();
+        }
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public override Dictionary<string, string> ExpectedStatistics => new()
+        {
+            {"Total Trades", "49"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "0%"},
+            {"Drawdown", "0%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "0%"},
+            {"Sharpe Ratio", "0"},
+            {"Probabilistic Sharpe Ratio", "0%"},
+            {"Loss Rate", "0%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "0"},
+            {"Beta", "0"},
+            {"Annual Standard Deviation", "0"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "0"},
+            {"Tracking Error", "0"},
+            {"Treynor Ratio", "0"},
+            {"Total Fees", "$45.62"},
+            {"Estimated Strategy Capacity", "$220000.00"},
+            {"Lowest Capacity Asset", "BTCUSDT 18N"},
+            {"Fitness Score", "0.208"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "79228162514264337593543950335"},
+            {"Return Over Maximum Drawdown", "26.189"},
+            {"Portfolio Turnover", "0.208"},
+            {"Total Insights Generated", "0"},
+            {"Total Insights Closed", "0"},
+            {"Total Insights Analysis Completed", "0"},
+            {"Long Insight Count", "0"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "USDT0"},
+            {"Total Accumulated Estimated Alpha Value", "USDT0"},
+            {"Mean Population Estimated Insight Value", "USDT0"},
+            {"Mean Population Direction", "0%"},
+            {"Mean Population Magnitude", "0%"},
+            {"Rolling Averaged Population Direction", "0%"},
+            {"Rolling Averaged Population Magnitude", "0%"},
+            {"OrderListHash", "7417649395922ff3791471b4f3b5c021"}
+        };
+    }
+}

Algorithm.CSharp/BitfinexCashAccountFeeRegressionAlgorithm.cs

@@ -0,0 +1,84 @@
+/*
+ * 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.
+*/
+
+using QuantConnect.Brokerages;
+using System.Collections.Generic;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Bitfinex cash account regression algorithm, reproduces issue https://github.com/QuantConnect/Lean/issues/6123
+    /// </summary>
+    public class BitfinexCashAccountFeeRegressionAlgorithm : CryptoCashAccountFeeRegressionAlgorithm
+    {
+        public override void Initialize()
+        {
+            SetStartDate(2013, 10, 02);
+            SetEndDate(2013, 10, 03);
+            BrokerageName = BrokerageName.Bitfinex;
+            Pair = "BTCUSD";
+            base.Initialize();
+        }
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public override Dictionary<string, string> ExpectedStatistics => new()
+        {
+            {"Total Trades", "49"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "0%"},
+            {"Drawdown", "0%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "0%"},
+            {"Sharpe Ratio", "0"},
+            {"Probabilistic Sharpe Ratio", "0%"},
+            {"Loss Rate", "0%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "0"},
+            {"Beta", "0"},
+            {"Annual Standard Deviation", "0"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "0"},
+            {"Tracking Error", "0"},
+            {"Treynor Ratio", "0"},
+            {"Total Fees", "$1.13"},
+            {"Estimated Strategy Capacity", "$2000.00"},
+            {"Lowest Capacity Asset", "BTCUSD E3"},
+            {"Fitness Score", "0.002"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "79228162514264337593543950335"},
+            {"Return Over Maximum Drawdown", "79228162514264337593543950335"},
+            {"Portfolio Turnover", "0.002"},
+            {"Total Insights Generated", "0"},
+            {"Total Insights Closed", "0"},
+            {"Total Insights Analysis Completed", "0"},
+            {"Long Insight Count", "0"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "$0"},
+            {"Total Accumulated Estimated Alpha Value", "$0"},
+            {"Mean Population Estimated Insight Value", "$0"},
+            {"Mean Population Direction", "0%"},
+            {"Mean Population Magnitude", "0%"},
+            {"Rolling Averaged Population Direction", "0%"},
+            {"Rolling Averaged Population Magnitude", "0%"},
+            {"OrderListHash", "7f892f0c42d8826ff770ee602fe207a2"}
+        };
+    }
+}

Algorithm.CSharp/BlackLittermanPortfolioOptimizationFrameworkAlgorithm.cs

@@ -85,18 +85,18 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "1.100%"},
             {"Expectancy", "-1"},
             {"Net Profit", "0.667%"},
-            {"Sharpe Ratio", "3.507"},
-            {"Probabilistic Sharpe Ratio", "59.181%"},
+            {"Sharpe Ratio", "3.993"},
+            {"Probabilistic Sharpe Ratio", "58.777%"},
             {"Loss Rate", "100%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "-0.384"},
-            {"Beta", "0.564"},
-            {"Annual Standard Deviation", "0.116"},
-            {"Annual Variance", "0.013"},
-            {"Information Ratio", "-10.791"},
-            {"Tracking Error", "0.092"},
-            {"Treynor Ratio", "0.718"},
+            {"Alpha", "-0.598"},
+            {"Beta", "0.569"},
+            {"Annual Standard Deviation", "0.133"},
+            {"Annual Variance", "0.018"},
+            {"Information Ratio", "-13.973"},
+            {"Tracking Error", "0.104"},
+            {"Treynor Ratio", "0.932"},
             {"Total Fees", "$46.20"},
             {"Estimated Strategy Capacity", "$2300000.00"},
             {"Lowest Capacity Asset", "AIG R735QTJ8XC9X"},

Algorithm.CSharp/CfdTimeZonesRegressionAlgorithm.cs

@@ -33,11 +33,11 @@ namespace QuantConnect.Algorithm.CSharp
         {
             SetAccountCurrency("EUR");
 
-            SetStartDate(2019, 2, 20);
+            SetStartDate(2019, 2, 19);
             SetEndDate(2019, 2, 21);
             SetCash("EUR", 100000);
 
-            _symbol = AddCfd("DE30EUR", Resolution.Minute, Market.Oanda).Symbol;
+            _symbol = AddCfd("DE30EUR").Symbol;
 
             SetBenchmark(_symbol);
         }
@@ -75,34 +75,34 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
-            {"Total Trades", "251"},
+            {"Total Trades", "279"},
             {"Average Win", "0.01%"},
             {"Average Loss", "-0.01%"},
-            {"Compounding Annual Return", "-37.465%"},
+            {"Compounding Annual Return", "-33.650%"},
             {"Drawdown", "0.300%"},
-            {"Expectancy", "-0.285"},
-            {"Net Profit", "-0.257%"},
-            {"Sharpe Ratio", "-40.568"},
+            {"Expectancy", "-0.345"},
+            {"Net Profit", "-0.337%"},
+            {"Sharpe Ratio", "-19.772"},
             {"Probabilistic Sharpe Ratio", "0%"},
-            {"Loss Rate", "66%"},
-            {"Win Rate", "34%"},
-            {"Profit-Loss Ratio", "1.08"},
+            {"Loss Rate", "68%"},
+            {"Win Rate", "32%"},
+            {"Profit-Loss Ratio", "1.07"},
             {"Alpha", "0"},
             {"Beta", "0"},
-            {"Annual Standard Deviation", "0.006"},
+            {"Annual Standard Deviation", "0.014"},
             {"Annual Variance", "0"},
-            {"Information Ratio", "-40.568"},
-            {"Tracking Error", "0.006"},
+            {"Information Ratio", "-19.772"},
+            {"Tracking Error", "0.014"},
             {"Treynor Ratio", "0"},
             {"Total Fees", "$0.00"},
-            {"Estimated Strategy Capacity", "$660000.00"},
+            {"Estimated Strategy Capacity", "$670000.00"},
             {"Lowest Capacity Asset", "DE30EUR 8I"},
-            {"Fitness Score", "0.002"},
+            {"Fitness Score", "0"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "-23.868"},
-            {"Return Over Maximum Drawdown", "-170.818"},
-            {"Portfolio Turnover", "12.673"},
+            {"Sortino Ratio", "-101.587"},
+            {"Return Over Maximum Drawdown", "-110.633"},
+            {"Portfolio Turnover", "9.513"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
             {"Total Insights Analysis Completed", "0"},
@@ -116,7 +116,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "6745cf313aa3ef780d052ca3ba933c6c"}
+            {"OrderListHash", "64c098abe3c1e7206424b0c3825b0069"}
         };
     }
 }

Algorithm.CSharp/ClassicRenkoConsolidatorAlgorithm.cs

@@ -27,7 +27,7 @@ namespace QuantConnect.Algorithm.CSharp
     /// <meta name="tag" content="indicators" />
     /// <meta name="tag" content="using data" />
     /// <meta name="tag" content="consolidating data" />
-    public class RenkoConsolidatorAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    public class ClassicRenkoConsolidatorAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
     {
         /// <summary>
         /// Initializes the algorithm state.
@@ -43,7 +43,7 @@ namespace QuantConnect.Algorithm.CSharp
             // property of the data it receives.
 
             // break SPY into $2.5 renko bricks and send that data to our 'OnRenkoBar' method
-            var renkoClose = new RenkoConsolidator(2.5m);
+            var renkoClose = new ClassicRenkoConsolidator(2.5m);
             renkoClose.DataConsolidated += (sender, consolidated) =>
             {
                 // call our event handler for renko data
@@ -58,7 +58,7 @@ namespace QuantConnect.Algorithm.CSharp
             // this allows us to perform the renko logic on values other than Close, even computed values!
 
             // break SPY into (2*o + h + l + 3*c)/7
-            var renko7bar = new RenkoConsolidator<TradeBar>(2.5m, x => (2 * x.Open + x.High + x.Low + 3 * x.Close) / 7m, x => x.Volume);
+            var renko7bar = new ClassicRenkoConsolidator<TradeBar>(2.5m, x => (2 * x.Open + x.High + x.Low + 3 * x.Close) / 7m, x => x.Volume);
             renko7bar.DataConsolidated += (sender, consolidated) =>
             {
                 HandleRenko7Bar(consolidated);
@@ -123,18 +123,18 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "6.800%"},
             {"Expectancy", "0.281"},
             {"Net Profit", "7.841%"},
-            {"Sharpe Ratio", "0.878"},
-            {"Probabilistic Sharpe Ratio", "43.343%"},
+            {"Sharpe Ratio", "0.799"},
+            {"Probabilistic Sharpe Ratio", "39.344%"},
             {"Loss Rate", "43%"},
             {"Win Rate", "57%"},
             {"Profit-Loss Ratio", "1.24"},
-            {"Alpha", "0.065"},
-            {"Beta", "0.013"},
-            {"Annual Standard Deviation", "0.077"},
-            {"Annual Variance", "0.006"},
-            {"Information Ratio", "-0.513"},
-            {"Tracking Error", "0.139"},
-            {"Treynor Ratio", "5.253"},
+            {"Alpha", "0.009"},
+            {"Beta", "0.411"},
+            {"Annual Standard Deviation", "0.07"},
+            {"Annual Variance", "0.005"},
+            {"Information Ratio", "-0.703"},
+            {"Tracking Error", "0.083"},
+            {"Treynor Ratio", "0.136"},
             {"Total Fees", "$129.35"},
             {"Estimated Strategy Capacity", "$1000000000.00"},
             {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},

Algorithm.CSharp/CoarseFineFundamentalRegressionAlgorithm.cs

@@ -168,18 +168,18 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "1.400%"},
             {"Expectancy", "0"},
             {"Net Profit", "1.163%"},
-            {"Sharpe Ratio", "2.876"},
-            {"Probabilistic Sharpe Ratio", "64.984%"},
+            {"Sharpe Ratio", "2.754"},
+            {"Probabilistic Sharpe Ratio", "64.748%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "100%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "0.237"},
-            {"Beta", "-0.188"},
-            {"Annual Standard Deviation", "0.089"},
-            {"Annual Variance", "0.008"},
-            {"Information Ratio", "2.409"},
-            {"Tracking Error", "0.148"},
-            {"Treynor Ratio", "-1.358"},
+            {"Alpha", "0.277"},
+            {"Beta", "0.436"},
+            {"Annual Standard Deviation", "0.086"},
+            {"Annual Variance", "0.007"},
+            {"Information Ratio", "3.572"},
+            {"Tracking Error", "0.092"},
+            {"Treynor Ratio", "0.54"},
             {"Total Fees", "$2.00"},
             {"Estimated Strategy Capacity", "$49000000.00"},
             {"Lowest Capacity Asset", "IBM R735QTJ8XC9X"},

Algorithm.CSharp/CoarseFineOptionUniverseChainRegressionAlgorithm.cs

@@ -41,7 +41,7 @@ namespace QuantConnect.Algorithm.CSharp
             _aapl = QuantConnect.Symbol.Create("AAPL", SecurityType.Equity, Market.USA);
             UniverseSettings.Resolution = Resolution.Minute;
 
-            SetStartDate(2014, 06, 05);
+            SetStartDate(2014, 06, 04);
             SetEndDate(2014, 06, 06);
 
             var selectionUniverse = AddUniverse(enumerable => new[] { Time.Date <= new DateTime(2014, 6, 5) ? _twx : _aapl },
@@ -144,34 +144,12 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
-            {"Total Trades", "13"},
-            {"Average Win", "0.65%"},
-            {"Average Loss", "-0.05%"},
-            {"Compounding Annual Return", "79228162514264337593543950335%"},
-            {"Drawdown", "0.500%"},
-            {"Expectancy", "1.393"},
-            {"Net Profit", "149.699%"},
-            {"Sharpe Ratio", "4.743312616499238E+27"},
-            {"Probabilistic Sharpe Ratio", "0%"},
-            {"Loss Rate", "83%"},
-            {"Win Rate", "17%"},
-            {"Profit-Loss Ratio", "13.36"},
-            {"Alpha", "7.922816251426434E+28"},
-            {"Beta", "304.581"},
-            {"Annual Standard Deviation", "16.703"},
-            {"Annual Variance", "278.995"},
-            {"Information Ratio", "4.75893717482582E+27"},
-            {"Tracking Error", "16.648"},
-            {"Treynor Ratio", "2.6012216611301735E+26"},
-            {"Total Fees", "$13.20"},
-            {"Estimated Strategy Capacity", "$3000000.00"},
-            {"Lowest Capacity Asset", "AOL VRKS95ENLBYE|AOL R735QTJ8XC9X"},
-            {"Fitness Score", "0.18"},
+            {"Fitness Score", "0.12"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
             {"Sortino Ratio", "79228162514264337593543950335"},
             {"Return Over Maximum Drawdown", "79228162514264337593543950335"},
-            {"Portfolio Turnover", "0.18"},
+            {"Portfolio Turnover", "0.12"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
             {"Total Insights Analysis Completed", "0"},

Algorithm.CSharp/CoarseFundamentalTop3Algorithm.cs

@@ -123,18 +123,18 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "1.700%"},
             {"Expectancy", "0.850"},
             {"Net Profit", "0.637%"},
-            {"Sharpe Ratio", "1.131"},
-            {"Probabilistic Sharpe Ratio", "50.538%"},
+            {"Sharpe Ratio", "1.088"},
+            {"Probabilistic Sharpe Ratio", "50.223%"},
             {"Loss Rate", "40%"},
             {"Win Rate", "60%"},
             {"Profit-Loss Ratio", "2.08"},
-            {"Alpha", "0.186"},
-            {"Beta", "0.465"},
-            {"Annual Standard Deviation", "0.123"},
-            {"Annual Variance", "0.015"},
-            {"Information Ratio", "1.908"},
-            {"Tracking Error", "0.126"},
-            {"Treynor Ratio", "0.299"},
+            {"Alpha", "0.198"},
+            {"Beta", "0.741"},
+            {"Annual Standard Deviation", "0.118"},
+            {"Annual Variance", "0.014"},
+            {"Information Ratio", "2.294"},
+            {"Tracking Error", "0.097"},
+            {"Treynor Ratio", "0.173"},
             {"Total Fees", "$27.94"},
             {"Estimated Strategy Capacity", "$200000000.00"},
             {"Lowest Capacity Asset", "AAPL R735QTJ8XC9X"},

Algorithm.CSharp/CoarseSelectionTimeRegressionAlgorithm.cs

@@ -107,18 +107,18 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "1.000%"},
             {"Expectancy", "0"},
             {"Net Profit", "1.003%"},
-            {"Sharpe Ratio", "5.024"},
-            {"Probabilistic Sharpe Ratio", "68.421%"},
+            {"Sharpe Ratio", "5.36"},
+            {"Probabilistic Sharpe Ratio", "69.521%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "0.312"},
-            {"Beta", "0.27"},
+            {"Alpha", "0"},
+            {"Beta", "1.003"},
             {"Annual Standard Deviation", "0.087"},
-            {"Annual Variance", "0.008"},
-            {"Information Ratio", "-0.242"},
-            {"Tracking Error", "0.105"},
-            {"Treynor Ratio", "1.616"},
+            {"Annual Variance", "0.007"},
+            {"Information Ratio", "6.477"},
+            {"Tracking Error", "0"},
+            {"Treynor Ratio", "0.462"},
             {"Total Fees", "$3.08"},
             {"Estimated Strategy Capacity", "$720000000.00"},
             {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},

Algorithm.CSharp/ConsolidateRegressionAlgorithm.cs

@@ -147,22 +147,22 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "1"},
             {"Average Win", "0%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "-99.999%"},
-            {"Drawdown", "16.100%"},
+            {"Compounding Annual Return", "0%"},
+            {"Drawdown", "0%"},
             {"Expectancy", "0"},
-            {"Net Profit", "-6.366%"},
-            {"Sharpe Ratio", "1.194"},
+            {"Net Profit", "0%"},
+            {"Sharpe Ratio", "0"},
             {"Probabilistic Sharpe Ratio", "0%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "5.56"},
-            {"Beta", "-71.105"},
-            {"Annual Standard Deviation", "0.434"},
-            {"Annual Variance", "0.188"},
-            {"Information Ratio", "1.016"},
-            {"Tracking Error", "0.44"},
-            {"Treynor Ratio", "-0.007"},
+            {"Alpha", "0"},
+            {"Beta", "0"},
+            {"Annual Standard Deviation", "0"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "0"},
+            {"Tracking Error", "0"},
+            {"Treynor Ratio", "0"},
             {"Total Fees", "$20.35"},
             {"Estimated Strategy Capacity", "$19000000.00"},
             {"Lowest Capacity Asset", "ES VMKLFZIH2MTD"},

Algorithm.CSharp/ConstituentsUniverseRegressionAlgorithm.cs

@@ -177,18 +177,18 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "0.900%"},
             {"Expectancy", "-1"},
             {"Net Profit", "-0.540%"},
-            {"Sharpe Ratio", "-3.168"},
-            {"Probabilistic Sharpe Ratio", "23.963%"},
+            {"Sharpe Ratio", "-3.349"},
+            {"Probabilistic Sharpe Ratio", "25.715%"},
             {"Loss Rate", "100%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "-0.456"},
-            {"Beta", "0.157"},
-            {"Annual Standard Deviation", "0.075"},
-            {"Annual Variance", "0.006"},
-            {"Information Ratio", "-9.176"},
-            {"Tracking Error", "0.178"},
-            {"Treynor Ratio", "-1.514"},
+            {"Alpha", "-0.724"},
+            {"Beta", "0.22"},
+            {"Annual Standard Deviation", "0.086"},
+            {"Annual Variance", "0.007"},
+            {"Information Ratio", "-12.125"},
+            {"Tracking Error", "0.187"},
+            {"Treynor Ratio", "-1.304"},
             {"Total Fees", "$32.32"},
             {"Estimated Strategy Capacity", "$95000000.00"},
             {"Lowest Capacity Asset", "AAPL R735QTJ8XC9X"},

Algorithm.CSharp/ContinuousBackMonthRawFutureRegressionAlgorithm.cs

@@ -0,0 +1,184 @@
+/*
+ * 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.
+*/
+
+using System;
+using System.Linq;
+using QuantConnect.Data;
+using QuantConnect.Orders;
+using QuantConnect.Interfaces;
+using QuantConnect.Securities;
+using QuantConnect.Data.Market;
+using System.Collections.Generic;
+using QuantConnect.Securities.Future;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Continuous Back Month Raw Futures Regression algorithm. Asserting and showcasing the behavior of adding a continuous future
+    /// </summary>
+    public class ContinuousBackMonthRawFutureRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private List<SymbolChangedEvent> _mappings = new();
+        private Future _continuousContract;
+        private DateTime _lastDateLog;
+
+        /// <summary>
+        /// Initialise the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must initialized.
+        /// </summary>
+        public override void Initialize()
+        {
+            SetStartDate(2013, 7, 1);
+            SetEndDate(2014, 1, 1);
+
+            _continuousContract = AddFuture(Futures.Indices.SP500EMini,
+                dataNormalizationMode: DataNormalizationMode.Raw,
+                dataMappingMode: DataMappingMode.FirstDayMonth,
+                contractDepthOffset: 1
+            );
+        }
+
+        /// <summary>
+        /// OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here.
+        /// </summary>
+        /// <param name="data">Slice object keyed by symbol containing the stock data</param>
+        public override void OnData(Slice data)
+        {
+            if (data.Keys.Count != 1)
+            {
+                throw new Exception($"We are getting data for more than one symbols! {string.Join(",", data.Keys.Select(symbol => symbol))}");
+            }
+
+            foreach (var changedEvent in data.SymbolChangedEvents.Values)
+            {
+                if (changedEvent.Symbol == _continuousContract.Symbol)
+                {
+                    _mappings.Add(changedEvent);
+                    Log($"SymbolChanged event: {changedEvent}");
+
+                    var currentExpiration = changedEvent.Symbol.Underlying.ID.Date;
+                    // +4 months cause we are actually using the back month, es is quarterly contract
+                    var frontMonthExpiration = FuturesExpiryFunctions.FuturesExpiryFunction(_continuousContract.Symbol)(Time.AddMonths(1 + 4));
+
+                    if (currentExpiration != frontMonthExpiration.Date)
+                    {
+                        throw new Exception($"Unexpected current mapped contract expiration {currentExpiration}" +
+                            $" @ {Time} it should be AT front month expiration {frontMonthExpiration}");
+                    }
+                }
+            }
+
+            if (_lastDateLog.Month != Time.Month && _continuousContract.HasData)
+            {
+                _lastDateLog = Time;
+
+                Log($"{Time}- {Securities[_continuousContract.Symbol].GetLastData()}");
+                if (Portfolio.Invested)
+                {
+                    Liquidate();
+                }
+                else
+                {
+                    // This works because we set this contract as tradable, even if it's a canonical security
+                    Buy(_continuousContract.Symbol, 1);
+                }
+
+                if(Time.Month == 1 && Time.Year == 2013)
+                {
+                    var response = History(new[] { _continuousContract.Symbol }, 60 * 24 * 90);
+                    if (!response.Any())
+                    {
+                        throw new Exception("Unexpected empty history response");
+                    }
+                }
+            }
+        }
+
+        public override void OnOrderEvent(OrderEvent orderEvent)
+        {
+            if (orderEvent.Status == OrderStatus.Filled)
+            {
+                Log($"{orderEvent}");
+            }
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            var expectedMappingCounts = 2;
+            if (_mappings.Count != expectedMappingCounts)
+            {
+                throw new Exception($"Unexpected symbol changed events: {_mappings.Count}, was expecting {expectedMappingCounts}");
+            }
+        }
+
+        /// <summary>
+        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
+        /// </summary>
+        public bool CanRunLocally { get; } = true;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public Language[] Languages { get; } = { Language.CSharp };
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        {
+            {"Total Trades", "2"},
+            {"Average Win", "1.16%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "2.311%"},
+            {"Drawdown", "1.600%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "1.159%"},
+            {"Sharpe Ratio", "0.753"},
+            {"Probabilistic Sharpe Ratio", "39.483%"},
+            {"Loss Rate", "0%"},
+            {"Win Rate", "100%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "-0.006"},
+            {"Beta", "0.099"},
+            {"Annual Standard Deviation", "0.022"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "-2.732"},
+            {"Tracking Error", "0.076"},
+            {"Treynor Ratio", "0.165"},
+            {"Total Fees", "$3.70"},
+            {"Estimated Strategy Capacity", "$3900000.00"},
+            {"Lowest Capacity Asset", "ES 1S1"},
+            {"Fitness Score", "0.007"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "0.563"},
+            {"Return Over Maximum Drawdown", "1.87"},
+            {"Portfolio Turnover", "0.01"},
+            {"Total Insights Generated", "0"},
+            {"Total Insights Closed", "0"},
+            {"Total Insights Analysis Completed", "0"},
+            {"Long Insight Count", "0"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "$0"},
+            {"Total Accumulated Estimated Alpha Value", "$0"},
+            {"Mean Population Estimated Insight Value", "$0"},
+            {"Mean Population Direction", "0%"},
+            {"Mean Population Magnitude", "0%"},
+            {"Rolling Averaged Population Direction", "0%"},
+            {"Rolling Averaged Population Magnitude", "0%"},
+            {"OrderListHash", "8aa2ed1319e8bb5beb403476a5aebfef"}
+        };
+    }
+}

Algorithm.CSharp/ContinuousFutureBackMonthRegressionAlgorithm.cs

@@ -0,0 +1,197 @@
+/*
+ * 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.
+*/
+
+using System;
+using System.Linq;
+using QuantConnect.Data;
+using QuantConnect.Orders;
+using QuantConnect.Interfaces;
+using QuantConnect.Securities;
+using QuantConnect.Data.Market;
+using System.Collections.Generic;
+using QuantConnect.Securities.Future;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Continuous Futures Back Month #1 Regression algorithm. Asserting and showcasing the behavior of adding a continuous future
+    /// </summary>
+    public class ContinuousFutureBackMonthRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private List<SymbolChangedEvent> _mappings = new();
+        private Future _continuousContract;
+        private DateTime _lastDateLog;
+
+        /// <summary>
+        /// Initialise the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must initialized.
+        /// </summary>
+        public override void Initialize()
+        {
+            SetStartDate(2013, 7, 1);
+            SetEndDate(2014, 1, 1);
+
+            try
+            {
+                AddFuture(Futures.Indices.SP500EMini,
+                    dataNormalizationMode: DataNormalizationMode.BackwardsPanamaCanal,
+                    dataMappingMode: DataMappingMode.OpenInterest,
+                    contractDepthOffset: 5
+                );
+                throw new Exception("Expected out of rage exception. We don't support that many back months");
+            }
+            catch (ArgumentOutOfRangeException)
+            {
+                // expected
+            }
+
+            _continuousContract = AddFuture(Futures.Indices.SP500EMini,
+                dataNormalizationMode: DataNormalizationMode.BackwardsPanamaCanal,
+                dataMappingMode: DataMappingMode.OpenInterest,
+                contractDepthOffset: 1
+            );
+        }
+
+        /// <summary>
+        /// OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here.
+        /// </summary>
+        /// <param name="data">Slice object keyed by symbol containing the stock data</param>
+        public override void OnData(Slice data)
+        {
+            if (data.Keys.Count != 1)
+            {
+                throw new Exception($"We are getting data for more than one symbols! {string.Join(",", data.Keys.Select(symbol => symbol))}");
+            }
+
+            foreach (var changedEvent in data.SymbolChangedEvents.Values)
+            {
+                if (changedEvent.Symbol == _continuousContract.Symbol)
+                {
+                    _mappings.Add(changedEvent);
+                    Log($"SymbolChanged event: {changedEvent}");
+
+                    var backMonthExpiration = changedEvent.Symbol.Underlying.ID.Date;
+                    var frontMonthExpiration = FuturesExpiryFunctions.FuturesExpiryFunction(_continuousContract.Symbol)(Time.AddMonths(1));
+
+                    if (backMonthExpiration <= frontMonthExpiration.Date)
+                    {
+                        throw new Exception($"Unexpected current mapped contract expiration {backMonthExpiration}" +
+                            $" @ {Time} it should be AFTER front month expiration {frontMonthExpiration}");
+                    }
+                }
+            }
+
+            if (_lastDateLog.Month != Time.Month && _continuousContract.HasData)
+            {
+                _lastDateLog = Time;
+
+                Log($"{Time}- {Securities[_continuousContract.Symbol].GetLastData()}");
+                if (Portfolio.Invested)
+                {
+                    Liquidate();
+                }
+                else
+                {
+                    // This works because we set this contract as tradable, even if it's a canonical security
+                    Buy(_continuousContract.Symbol, 1);
+                }
+
+                if(Time.Month == 1 && Time.Year == 2013)
+                {
+                    var response = History(new[] { _continuousContract.Symbol }, 60 * 24 * 90);
+                    if (!response.Any())
+                    {
+                        throw new Exception("Unexpected empty history response");
+                    }
+                }
+            }
+        }
+
+        public override void OnOrderEvent(OrderEvent orderEvent)
+        {
+            if (orderEvent.Status == OrderStatus.Filled)
+            {
+                Log($"{orderEvent}");
+            }
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            var expectedMappingCounts = 2;
+            if (_mappings.Count != expectedMappingCounts)
+            {
+                throw new Exception($"Unexpected symbol changed events: {_mappings.Count}, was expecting {expectedMappingCounts}");
+            }
+        }
+
+        /// <summary>
+        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
+        /// </summary>
+        public bool CanRunLocally { get; } = true;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public Language[] Languages { get; } = { Language.CSharp };
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        {
+            {"Total Trades", "3"},
+            {"Average Win", "1.16%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "2.229%"},
+            {"Drawdown", "1.600%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "1.118%"},
+            {"Sharpe Ratio", "0.726"},
+            {"Probabilistic Sharpe Ratio", "38.511%"},
+            {"Loss Rate", "0%"},
+            {"Win Rate", "100%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "-0.007"},
+            {"Beta", "0.099"},
+            {"Annual Standard Deviation", "0.022"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "-2.74"},
+            {"Tracking Error", "0.076"},
+            {"Treynor Ratio", "0.159"},
+            {"Total Fees", "$5.55"},
+            {"Estimated Strategy Capacity", "$290000.00"},
+            {"Lowest Capacity Asset", "ES 1S1"},
+            {"Fitness Score", "0.009"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "0.498"},
+            {"Return Over Maximum Drawdown", "1.803"},
+            {"Portfolio Turnover", "0.014"},
+            {"Total Insights Generated", "0"},
+            {"Total Insights Closed", "0"},
+            {"Total Insights Analysis Completed", "0"},
+            {"Long Insight Count", "0"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "$0"},
+            {"Total Accumulated Estimated Alpha Value", "$0"},
+            {"Mean Population Estimated Insight Value", "$0"},
+            {"Mean Population Direction", "0%"},
+            {"Mean Population Magnitude", "0%"},
+            {"Rolling Averaged Population Direction", "0%"},
+            {"Rolling Averaged Population Magnitude", "0%"},
+            {"OrderListHash", "e669103cc598f59d85f5e8d5f0b8df30"}
+        };
+    }
+}

Algorithm.CSharp/ContinuousFutureHistoryRegressionAlgorithm.cs

@@ -0,0 +1,163 @@
+/*
+ * 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.
+*/
+
+using System;
+using System.Linq;
+using QuantConnect.Data;
+using QuantConnect.Interfaces;
+using QuantConnect.Securities;
+using System.Collections.Generic;
+using QuantConnect.Securities.Future;
+using QuantConnect.Data.UniverseSelection;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Continuous Futures History Regression algorithm. Asserting and showcasing the behavior of adding a continuous future
+    /// </summary>
+    public class ContinuousFutureHistoryRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Future _continuousContract;
+        private bool _warmedUp;
+
+        /// <summary>
+        /// Initialise the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must initialized.
+        /// </summary>
+        public override void Initialize()
+        {
+            SetStartDate(2013, 10, 10);
+            SetEndDate(2013, 10, 11);
+
+            _continuousContract = AddFuture(Futures.Indices.SP500EMini,
+                dataNormalizationMode: DataNormalizationMode.BackwardsRatio,
+                dataMappingMode: DataMappingMode.OpenInterest,
+                contractDepthOffset: 1
+            );
+            SetWarmup(10);
+        }
+
+        /// <summary>
+        /// OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here.
+        /// </summary>
+        /// <param name="data">Slice object keyed by symbol containing the stock data</param>
+        public override void OnData(Slice data)
+        {
+            if (IsWarmingUp)
+            {
+                // warm up data
+                _warmedUp = true;
+
+                if (!_continuousContract.HasData)
+                {
+                    throw new Exception($"ContinuousContract did not get any data during warmup!");
+                }
+
+                var backMonthExpiration =   data.Keys.Single().Underlying.ID.Date;
+                var frontMonthExpiration = FuturesExpiryFunctions.FuturesExpiryFunction(_continuousContract.Symbol)(Time.AddMonths(1));
+                if (backMonthExpiration <= frontMonthExpiration.Date)
+                {
+                    throw new Exception($"Unexpected current mapped contract expiration {backMonthExpiration}" +
+                        $" @ {Time} it should be AFTER front month expiration {frontMonthExpiration}");
+                }
+            }
+            if (data.Keys.Count != 1)
+            {
+                throw new Exception($"We are getting data for more than one symbols! {string.Join(",", data.Keys.Select(symbol => symbol))}");
+            }
+
+            if (!Portfolio.Invested)
+            {
+                Buy(_continuousContract.Symbol, 1);
+            }
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            if (!_warmedUp)
+            {
+                throw new Exception("Algorithm didn't warm up!");
+            }
+        }
+
+        public override void OnSecuritiesChanged(SecurityChanges changes)
+        {
+            Debug($"{Time}-{changes}");
+            if (changes.AddedSecurities.Any(security => security.Symbol != _continuousContract.Symbol)
+                || changes.RemovedSecurities.Any(security => security.Symbol != _continuousContract.Symbol))
+            {
+                throw new Exception($"We got an unexpected security changes {changes}");
+            }
+        }
+
+        /// <summary>
+        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
+        /// </summary>
+        public bool CanRunLocally { get; } = true;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public Language[] Languages { get; } = { Language.CSharp };
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        {
+            {"Total Trades", "1"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "0%"},
+            {"Drawdown", "0%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "0%"},
+            {"Sharpe Ratio", "0"},
+            {"Probabilistic Sharpe Ratio", "0%"},
+            {"Loss Rate", "0%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "0"},
+            {"Beta", "0"},
+            {"Annual Standard Deviation", "0"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "0"},
+            {"Tracking Error", "0"},
+            {"Treynor Ratio", "0"},
+            {"Total Fees", "$1.85"},
+            {"Estimated Strategy Capacity", "$42000000.00"},
+            {"Lowest Capacity Asset", "ES 1S1"},
+            {"Fitness Score", "0.76"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "79228162514264337593543950335"},
+            {"Return Over Maximum Drawdown", "79228162514264337593543950335"},
+            {"Portfolio Turnover", "0.76"},
+            {"Total Insights Generated", "0"},
+            {"Total Insights Closed", "0"},
+            {"Total Insights Analysis Completed", "0"},
+            {"Long Insight Count", "0"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "$0"},
+            {"Total Accumulated Estimated Alpha Value", "$0"},
+            {"Mean Population Estimated Insight Value", "$0"},
+            {"Mean Population Direction", "0%"},
+            {"Mean Population Magnitude", "0%"},
+            {"Rolling Averaged Population Direction", "0%"},
+            {"Rolling Averaged Population Magnitude", "0%"},
+            {"OrderListHash", "4de9344671d542e30066338e2bf9d400"}
+        };
+    }
+}

Algorithm.CSharp/ContinuousFutureRegressionAlgorithm.cs

@@ -0,0 +1,212 @@
+/*
+ * 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.
+*/
+
+using System;
+using System.Linq;
+using QuantConnect.Data;
+using QuantConnect.Orders;
+using QuantConnect.Interfaces;
+using QuantConnect.Securities;
+using QuantConnect.Data.Market;
+using System.Collections.Generic;
+using QuantConnect.Securities.Future;
+using QuantConnect.Data.UniverseSelection;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Continuous Futures Regression algorithm. Asserting and showcasing the behavior of adding a continuous future
+    /// </summary>
+    public class ContinuousFutureRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private List<SymbolChangedEvent> _mappings = new();
+        private Symbol _currentMappedSymbol;
+        private Future _continuousContract;
+        private DateTime _lastMonth;
+
+        /// <summary>
+        /// Initialise the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must initialized.
+        /// </summary>
+        public override void Initialize()
+        {
+            SetStartDate(2013, 7, 1);
+            SetEndDate(2014, 1, 1);
+
+            _continuousContract = AddFuture(Futures.Indices.SP500EMini,
+                dataNormalizationMode: DataNormalizationMode.BackwardsRatio,
+                dataMappingMode: DataMappingMode.LastTradingDay,
+                contractDepthOffset: 0
+            );
+        }
+
+        /// <summary>
+        /// OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here.
+        /// </summary>
+        /// <param name="data">Slice object keyed by symbol containing the stock data</param>
+        public override void OnData(Slice data)
+        {
+            // we subtract a minute cause we can get data on the market close, from the previous minute
+            if (!_continuousContract.Exchange.DateTimeIsOpen(Time.AddMinutes(-1)))
+            {
+                if (data.Bars.Count > 0 || data.QuoteBars.Count > 0)
+                {
+                    throw new Exception($"We are getting data during closed market!");
+                }
+            }
+
+            var currentlyMappedSecurity = Securities[_continuousContract.Mapped];
+
+            if (data.Keys.Count != 1)
+            {
+                throw new Exception($"We are getting data for more than one symbols! {string.Join(",", data.Keys.Select(symbol => symbol))}");
+            }
+
+            foreach (var changedEvent in data.SymbolChangedEvents.Values)
+            {
+                if (changedEvent.Symbol == _continuousContract.Symbol)
+                {
+                    _mappings.Add(changedEvent);
+                    Log($"{Time} - SymbolChanged event: {changedEvent}");
+
+                    if (_currentMappedSymbol == _continuousContract.Mapped)
+                    {
+                        throw new Exception($"Continuous contract current symbol did not change! {_continuousContract.Mapped}");
+                    }
+
+                    var currentExpiration = changedEvent.Symbol.Underlying.ID.Date;
+                    var frontMonthExpiration = FuturesExpiryFunctions.FuturesExpiryFunction(_continuousContract.Symbol)(Time.AddMonths(1));
+
+                    if (currentExpiration != frontMonthExpiration.Date)
+                    {
+                        throw new Exception($"Unexpected current mapped contract expiration {currentExpiration}" +
+                            $" @ {Time} it should be AT front month expiration {frontMonthExpiration}");
+                    }
+                }
+            }
+            if (_lastMonth.Month != Time.Month && currentlyMappedSecurity.HasData)
+            {
+                _lastMonth = Time;
+
+                Log($"{Time}- {currentlyMappedSecurity.GetLastData()}");
+                if (Portfolio.Invested)
+                {
+                    Liquidate();
+                }
+                else
+                {
+                    // This works because we set this contract as tradable, even if it's a canonical security
+                    Buy(currentlyMappedSecurity.Symbol, 1);
+                }
+
+                if(Time.Month == 1 && Time.Year == 2013)
+                {
+                    var response = History(new[] { _continuousContract.Symbol }, 60 * 24 * 90);
+                    if (!response.Any())
+                    {
+                        throw new Exception("Unexpected empty history response");
+                    }
+                }
+            }
+
+            _currentMappedSymbol = _continuousContract.Mapped;
+        }
+
+        public override void OnOrderEvent(OrderEvent orderEvent)
+        {
+            if (orderEvent.Status == OrderStatus.Filled)
+            {
+                Log($"{orderEvent}");
+            }
+        }
+
+        public override void OnSecuritiesChanged(SecurityChanges changes)
+        {
+            Debug($"{Time}-{changes}");
+            if (changes.AddedSecurities.Any(security => security.Symbol != _continuousContract.Symbol)
+                || changes.RemovedSecurities.Any(security => security.Symbol != _continuousContract.Symbol))
+            {
+                throw new Exception($"We got an unexpected security changes {changes}");
+            }
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            var expectedMappingCounts = 2;
+            if (_mappings.Count != expectedMappingCounts)
+            {
+                throw new Exception($"Unexpected symbol changed events: {_mappings.Count}, was expecting {expectedMappingCounts}");
+            }
+        }
+
+        /// <summary>
+        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
+        /// </summary>
+        public bool CanRunLocally { get; } = true;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public Language[] Languages { get; } = { Language.CSharp, Language.Python };
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        {
+            {"Total Trades", "3"},
+            {"Average Win", "1.21%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "2.392%"},
+            {"Drawdown", "1.600%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "1.199%"},
+            {"Sharpe Ratio", "0.775"},
+            {"Probabilistic Sharpe Ratio", "40.287%"},
+            {"Loss Rate", "0%"},
+            {"Win Rate", "100%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "-0.006"},
+            {"Beta", "0.099"},
+            {"Annual Standard Deviation", "0.022"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "-2.726"},
+            {"Tracking Error", "0.076"},
+            {"Treynor Ratio", "0.169"},
+            {"Total Fees", "$5.55"},
+            {"Estimated Strategy Capacity", "$0"},
+            {"Lowest Capacity Asset", "ES VMKLFZIH2MTD"},
+            {"Fitness Score", "0.01"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "0.516"},
+            {"Return Over Maximum Drawdown", "1.935"},
+            {"Portfolio Turnover", "0.016"},
+            {"Total Insights Generated", "0"},
+            {"Total Insights Closed", "0"},
+            {"Total Insights Analysis Completed", "0"},
+            {"Long Insight Count", "0"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "$0"},
+            {"Total Accumulated Estimated Alpha Value", "$0"},
+            {"Mean Population Estimated Insight Value", "$0"},
+            {"Mean Population Direction", "0%"},
+            {"Mean Population Magnitude", "0%"},
+            {"Rolling Averaged Population Direction", "0%"},
+            {"Rolling Averaged Population Magnitude", "0%"},
+            {"OrderListHash", "8ad040c62ad255e4f9cd423364147e85"}
+        };
+    }
+}

Algorithm.CSharp/ConvertToFrameworkAlgorithm.cs

@@ -133,18 +133,18 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "53.000%"},
             {"Expectancy", "-0.053"},
             {"Net Profit", "-29.486%"},
-            {"Sharpe Ratio", "-0.078"},
-            {"Probabilistic Sharpe Ratio", "0.004%"},
+            {"Sharpe Ratio", "-0.072"},
+            {"Probabilistic Sharpe Ratio", "0.001%"},
             {"Loss Rate", "56%"},
             {"Win Rate", "44%"},
             {"Profit-Loss Ratio", "1.15"},
-            {"Alpha", "-0.013"},
-            {"Beta", "0.007"},
-            {"Annual Standard Deviation", "0.163"},
-            {"Annual Variance", "0.027"},
-            {"Information Ratio", "-0.393"},
-            {"Tracking Error", "0.238"},
-            {"Treynor Ratio", "-1.72"},
+            {"Alpha", "-0.004"},
+            {"Beta", "-0.095"},
+            {"Annual Standard Deviation", "0.149"},
+            {"Annual Variance", "0.022"},
+            {"Information Ratio", "-0.34"},
+            {"Tracking Error", "0.23"},
+            {"Treynor Ratio", "0.113"},
             {"Total Fees", "$796.82"},
             {"Estimated Strategy Capacity", "$1200000000.00"},
             {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},

Algorithm.CSharp/CryptoCashAccountFeeRegressionAlgorithm.cs

@@ -0,0 +1,105 @@
+/*
+ * 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.
+*/
+
+using System;
+using System.Linq;
+using QuantConnect.Util;
+using QuantConnect.Data;
+using QuantConnect.Orders;
+using QuantConnect.Interfaces;
+using QuantConnect.Brokerages;
+using System.Collections.Generic;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Base crypto cash account regression algorithm trading in and out
+    /// </summary>
+    public abstract class CryptoCashAccountFeeRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Symbol _symbol;
+
+        /// <summary>
+        /// The target brokerage model name
+        /// </summary>
+        protected BrokerageName BrokerageName { get; set; }
+
+        /// <summary>
+        /// The pair to add and trade
+        /// </summary>
+        protected string Pair { get; set; }
+
+        /// <summary>
+        /// Initialise the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must initialized.
+        /// </summary>
+        public override void Initialize()
+        {
+            SetBrokerageModel(BrokerageName, AccountType.Cash);
+            _symbol = AddCrypto(Pair, Resolution.Hour).Symbol;
+        }
+
+        /// <summary>
+        /// OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here.
+        /// </summary>
+        /// <param name="data">Slice object keyed by symbol containing the stock data</param>
+        public override void OnData(Slice data)
+        {
+            if (!Portfolio.Invested)
+            {
+                CurrencyPairUtil.DecomposeCurrencyPair(_symbol, out var baseCurrency, out var quoteCurrency);
+
+                var initialQuoteCurrency = Portfolio.CashBook[quoteCurrency].Amount;
+                var ticket = Buy(_symbol, 0.1m);
+                var filledEvent = ticket.OrderEvents.Single(orderEvent => orderEvent.Status == OrderStatus.Filled);
+
+                if (Portfolio.CashBook[baseCurrency].Amount != ticket.QuantityFilled
+                    || filledEvent.FillQuantity != ticket.QuantityFilled
+                    || (0.1m - filledEvent.OrderFee.Value.Amount) != ticket.QuantityFilled)
+                {
+                    throw new Exception($"Unexpected BaseCurrency porfoltio status. Event {filledEvent}. CashBook: {Portfolio.CashBook}. ");
+                }
+
+                if (Portfolio.CashBook[quoteCurrency].Amount != (initialQuoteCurrency - 0.1m * filledEvent.FillPrice))
+                {
+                    throw new Exception($"Unexpected QuoteCurrency porfoltio status. Event {filledEvent}. CashBook: {Portfolio.CashBook}. ");
+                }
+
+                if (Securities[_symbol].Holdings.Quantity != (0.1m - filledEvent.OrderFee.Value.Amount))
+                {
+                    throw new Exception($"Unexpected Holdings: {Securities[_symbol].Holdings}. Event {filledEvent}");
+                }
+            }
+            else
+            {
+                Liquidate();
+            }
+        }
+
+        /// <summary>
+        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
+        /// </summary>
+        public bool CanRunLocally { get; } = true;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public Language[] Languages { get; } = { Language.CSharp };
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public abstract Dictionary<string, string> ExpectedStatistics { get; }
+    }
+}

Algorithm.CSharp/CustomBuyingPowerModelAlgorithm.cs

@@ -104,18 +104,18 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "21.600%"},
             {"Expectancy", "0"},
             {"Net Profit", "38.619%"},
-            {"Sharpe Ratio", "33.779"},
-            {"Probabilistic Sharpe Ratio", "77.029%"},
+            {"Sharpe Ratio", "14.33"},
+            {"Probabilistic Sharpe Ratio", "75.756%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "32.812"},
-            {"Beta", "8.756"},
-            {"Annual Standard Deviation", "1.11"},
-            {"Annual Variance", "1.231"},
-            {"Information Ratio", "37.501"},
-            {"Tracking Error", "0.985"},
-            {"Treynor Ratio", "4.281"},
+            {"Alpha", "10.389"},
+            {"Beta", "8.754"},
+            {"Annual Standard Deviation", "0.95"},
+            {"Annual Variance", "0.903"},
+            {"Information Ratio", "15.703"},
+            {"Tracking Error", "0.844"},
+            {"Treynor Ratio", "1.555"},
             {"Total Fees", "$30.00"},
             {"Estimated Strategy Capacity", "$22000000.00"},
             {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},

Algorithm.CSharp/CustomDataIndicatorExtensionsAlgorithm.cs

@@ -1,4 +1,4 @@
-/*
+/*
  * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
  * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
  *
@@ -14,16 +14,17 @@
 */
 
 using System;
+using System.IO;
+using System.Globalization;
 using QuantConnect.Data;
-using QuantConnect.Data.Custom;
-using QuantConnect.Data.Market;
+using QuantConnect.Util;
 using QuantConnect.Indicators;
 
 namespace QuantConnect.Algorithm.CSharp
 {
     /// <summary>
     /// The algorithm creates new indicator value with the existing indicator method by Indicator Extensions
-    /// Demonstration of using the external custom datasource Quandl to request the VIX and VXV daily data
+    /// Demonstration of using local custom datasource CustomData to request the IBM and SPY daily data
     /// </summary>
     /// <meta name="tag" content="using data" />
     /// <meta name="tag" content="using quantconnect" />
@@ -34,10 +35,10 @@ namespace QuantConnect.Algorithm.CSharp
     /// <meta name="tag" content="charting" />
     public class CustomDataIndicatorExtensionsAlgorithm : QCAlgorithm
     {
-        private const string _vix = "CBOE/VIX";
-        private const string _vxv = "CBOE/VXV";
-        private SimpleMovingAverage _smaVIX;
-        private SimpleMovingAverage _smaVXV;
+        private const string _ibm = "IBM";
+        private const string _spy = "SPY";
+        private SimpleMovingAverage _smaIBM;
+        private SimpleMovingAverage _smaSPY;
         private IndicatorBase<IndicatorDataPoint> _ratio;
 
         /// <summary>
@@ -50,46 +51,82 @@ namespace QuantConnect.Algorithm.CSharp
             SetCash(25000);
 
             // Define the symbol and "type" of our generic data
-            AddData<QuandlVix>(_vix, Resolution.Daily);
-            AddData<Quandl>(_vxv, Resolution.Daily);
+            AddData<CustomData>(_ibm, Resolution.Daily);
+            AddData<CustomData>(_spy, Resolution.Daily);
             // Set up default Indicators, these are just 'identities' of the closing price
-            _smaVIX = SMA(_vix, 1);
-            _smaVXV = SMA(_vxv, 1);
-            // This will create a new indicator whose value is smaVXV / smaVIX
-            _ratio = _smaVXV.Over(_smaVIX);
+            _smaIBM = SMA(_ibm, 1);
+            _smaSPY = SMA(_spy, 1);
+            // This will create a new indicator whose value is smaSPY / smaIBM
+            _ratio = _smaSPY.Over(_smaIBM);
         }
 
         /// <summary>
         /// Custom data event handler:
         /// </summary>
-        /// <param name="data">Quandl - dictionary Bars of Quandl Data</param>
-        public void OnData(Quandl data)
+        /// <param name="data">CustomData - dictionary Bars of custom data</param>
+        public void OnData(CustomData data)
         {
             // Wait for all indicators to fully initialize
-            if (_smaVIX.IsReady && _smaVXV.IsReady && _ratio.IsReady)
+            if (_smaIBM.IsReady && _smaSPY.IsReady && _ratio.IsReady)
             {
                 if (!Portfolio.Invested && _ratio > 1)
                 {
-                    MarketOrder(_vix, 100);
+                    MarketOrder(_ibm, 100);
                 }
                 else if (_ratio < 1)
                 {
                     Liquidate();
                 }
                 // plot all indicators
-                PlotIndicator("SMA", _smaVIX, _smaVXV);
+                PlotIndicator("SMA", _smaIBM, _smaSPY);
                 PlotIndicator("Ratio", _ratio);
             }
         }
     }
 
     /// <summary>
-    /// In CBOE/VIX data, there is a "vix close" column instead of "close" which is the 
-    /// default column namein LEAN Quandl custom data implementation.
-    /// This class assigns new column name to match the the external datasource setting.
+    /// Custom data from local LEAN data
     /// </summary>
-    public class QuandlVix : Quandl
+    public class CustomData : BaseData
     {
-        public QuandlVix() : base(valueColumnName: "vix close") { }
+        public decimal Open;
+        public decimal High;
+        public decimal Low;
+        public decimal Close;
+
+        public override DateTime EndTime
+        {
+            get { return Time + Period; }
+            set { Time = value - Period; }
+        }
+
+        public TimeSpan Period
+        {
+            get { return QuantConnect.Time.OneDay; }
+        }
+
+        public override SubscriptionDataSource GetSource(SubscriptionDataConfig config, DateTime date, bool isLiveMode)
+        {
+            var source = Path.Combine(Globals.DataFolder, "equity", "usa", config.Resolution.ToString().ToLower(), LeanData.GenerateZipFileName(config.Symbol, date, config.Resolution, config.TickType));
+            return new SubscriptionDataSource(source, SubscriptionTransportMedium.LocalFile, FileFormat.Csv);
+        }
+
+        public override BaseData Reader(SubscriptionDataConfig config, string line, DateTime date, bool isLiveMode)
+        {
+            var csv = line.ToCsv(6);
+            var _scaleFactor = 1 / 10000m;
+
+            var custom = new CustomData
+            {
+                Symbol = config.Symbol,
+                Time = DateTime.ParseExact(csv[0], DateFormat.TwelveCharacter, CultureInfo.InvariantCulture),
+                Open = csv[1].ToDecimal() * _scaleFactor,
+                High = csv[2].ToDecimal() * _scaleFactor,
+                Low = csv[3].ToDecimal() * _scaleFactor,
+                Close = csv[4].ToDecimal() * _scaleFactor,
+                Value = csv[4].ToDecimal() * _scaleFactor
+            };
+            return custom;
+        }
     }
-}
+}

Algorithm.CSharp/CustomDataPropertiesRegressionAlgorithm.cs

@@ -123,13 +123,13 @@ namespace QuantConnect.Algorithm.CSharp
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "1.736"},
-            {"Beta", "0.142"},
+            {"Alpha", "1.747"},
+            {"Beta", "0.047"},
             {"Annual Standard Deviation", "0.84"},
             {"Annual Variance", "0.706"},
-            {"Information Ratio", "1.925"},
-            {"Tracking Error", "0.846"},
-            {"Treynor Ratio", "12.334"},
+            {"Information Ratio", "1.922"},
+            {"Tracking Error", "0.848"},
+            {"Treynor Ratio", "37.47"},
             {"Total Fees", "$0.00"},
             {"Estimated Strategy Capacity", "$0"},
             {"Lowest Capacity Asset", "BTC.Bitcoin 2S"},

Algorithm.CSharp/CustomDataRegressionAlgorithm.cs

@@ -18,7 +18,9 @@ using System.Collections.Generic;
 using System.Globalization;
 using Newtonsoft.Json;
 using QuantConnect.Data;
+using QuantConnect.Data.UniverseSelection;
 using QuantConnect.Interfaces;
+using QuantConnect.Securities;
 
 namespace QuantConnect.Algorithm.CSharp
 {
@@ -31,12 +33,14 @@ namespace QuantConnect.Algorithm.CSharp
     /// <meta name="tag" content="regression test" />
     public class CustomDataRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
     {
+        private bool _warmedUpChecked = false;
+
         /// <summary>
         /// Initialise the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must initialized.
         /// </summary>
         public override void Initialize()
         {
-            SetStartDate(2011, 9, 13);
+            SetStartDate(2011, 9, 14);
             SetEndDate(2015, 12, 01);
 
             //Set the cash for the strategy:
@@ -45,6 +49,9 @@ namespace QuantConnect.Algorithm.CSharp
             //Define the symbol and "type" of our generic data:
             var resolution = LiveMode ? Resolution.Second : Resolution.Daily;
             AddData<Bitcoin>("BTC", resolution);
+
+            var seeder = new FuncSecuritySeeder(GetLastKnownPrices);
+            SetSecurityInitializer(security => seeder.SeedSecurity(security));
         }
 
         /// <summary>
@@ -66,6 +73,30 @@ namespace QuantConnect.Algorithm.CSharp
             }
         }
 
+        public override void OnSecuritiesChanged(SecurityChanges changes)
+        {
+            changes.FilterCustomSecurities = false;
+            foreach (var addedSecurity in changes.AddedSecurities)
+            {
+                if (addedSecurity.Symbol.Value == "BTC")
+                {
+                    _warmedUpChecked = true;
+                }
+                if (!addedSecurity.HasData)
+                {
+                    throw new Exception($"Security {addedSecurity.Symbol} was not warmed up!");
+                }
+            }
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            if (!_warmedUpChecked)
+            {
+                throw new Exception($"Security was not warmed up!");
+            }
+        }
+
         /// <summary>
         /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
         /// </summary>
@@ -84,30 +115,30 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "1"},
             {"Average Win", "0%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "157.497%"},
+            {"Compounding Annual Return", "157.655%"},
             {"Drawdown", "84.800%"},
             {"Expectancy", "0"},
             {"Net Profit", "5319.007%"},
-            {"Sharpe Ratio", "2.086"},
-            {"Probabilistic Sharpe Ratio", "69.456%"},
+            {"Sharpe Ratio", "2.123"},
+            {"Probabilistic Sharpe Ratio", "70.581%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "1.736"},
-            {"Beta", "0.142"},
+            {"Alpha", "1.776"},
+            {"Beta", "0.059"},
             {"Annual Standard Deviation", "0.84"},
             {"Annual Variance", "0.706"},
-            {"Information Ratio", "1.925"},
-            {"Tracking Error", "0.846"},
-            {"Treynor Ratio", "12.333"},
+            {"Information Ratio", "1.962"},
+            {"Tracking Error", "0.847"},
+            {"Treynor Ratio", "30.455"},
             {"Total Fees", "$0.00"},
             {"Estimated Strategy Capacity", "$0"},
             {"Lowest Capacity Asset", "BTC.Bitcoin 2S"},
             {"Fitness Score", "0"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "2.269"},
-            {"Return Over Maximum Drawdown", "1.858"},
+            {"Sortino Ratio", "2.271"},
+            {"Return Over Maximum Drawdown", "1.86"},
             {"Portfolio Turnover", "0"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},

Algorithm.CSharp/CustomDataUsingMapFileRegressionAlgorithm.cs

@@ -128,18 +128,18 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "11.000%"},
             {"Expectancy", "0"},
             {"Net Profit", "-10.343%"},
-            {"Sharpe Ratio", "-1.554"},
-            {"Probabilistic Sharpe Ratio", "0.001%"},
+            {"Sharpe Ratio", "-1.696"},
+            {"Probabilistic Sharpe Ratio", "0.009%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "-0.91"},
-            {"Beta", "-5.602"},
-            {"Annual Standard Deviation", "0.643"},
-            {"Annual Variance", "0.413"},
-            {"Information Ratio", "-1.378"},
-            {"Tracking Error", "0.736"},
-            {"Treynor Ratio", "0.178"},
+            {"Alpha", "-0.924"},
+            {"Beta", "-5.612"},
+            {"Annual Standard Deviation", "0.587"},
+            {"Annual Variance", "0.345"},
+            {"Information Ratio", "-1.517"},
+            {"Tracking Error", "0.664"},
+            {"Treynor Ratio", "0.177"},
             {"Total Fees", "$0.00"},
             {"Estimated Strategy Capacity", "$0"},
             {"Lowest Capacity Asset", "NWSA.CustomDataUsingMapping T3MO1488O0H0"},

Algorithm.CSharp/CustomModelsAlgorithm.cs

@@ -199,18 +199,18 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "2.400%"},
             {"Expectancy", "-0.187"},
             {"Net Profit", "-0.629%"},
-            {"Sharpe Ratio", "-1.475"},
-            {"Probabilistic Sharpe Ratio", "23.597%"},
+            {"Sharpe Ratio", "-1.281"},
+            {"Probabilistic Sharpe Ratio", "21.874%"},
             {"Loss Rate", "70%"},
             {"Win Rate", "30%"},
             {"Profit-Loss Ratio", "1.73"},
-            {"Alpha", "-0.136"},
-            {"Beta", "0.126"},
-            {"Annual Standard Deviation", "0.047"},
+            {"Alpha", "-0.096"},
+            {"Beta", "0.122"},
+            {"Annual Standard Deviation", "0.04"},
             {"Annual Variance", "0.002"},
-            {"Information Ratio", "-5.094"},
-            {"Tracking Error", "0.118"},
-            {"Treynor Ratio", "-0.547"},
+            {"Information Ratio", "-4.126"},
+            {"Tracking Error", "0.102"},
+            {"Treynor Ratio", "-0.417"},
             {"Total Fees", "$62.25"},
             {"Estimated Strategy Capacity", "$52000000.00"},
             {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},

Algorithm.CSharp/CustomUniverseSelectionRegressionAlgorithm.cs

@@ -90,18 +90,18 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "1.200%"},
             {"Expectancy", "0"},
             {"Net Profit", "1.694%"},
-            {"Sharpe Ratio", "6.988"},
-            {"Probabilistic Sharpe Ratio", "68.188%"},
+            {"Sharpe Ratio", "8.671"},
+            {"Probabilistic Sharpe Ratio", "67.159%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "1.172"},
-            {"Beta", "0.14"},
-            {"Annual Standard Deviation", "0.196"},
-            {"Annual Variance", "0.038"},
-            {"Information Ratio", "-0.118"},
-            {"Tracking Error", "0.256"},
-            {"Treynor Ratio", "9.783"},
+            {"Alpha", "-0.053"},
+            {"Beta", "1.003"},
+            {"Annual Standard Deviation", "0.223"},
+            {"Annual Variance", "0.05"},
+            {"Information Ratio", "-35.82"},
+            {"Tracking Error", "0.001"},
+            {"Treynor Ratio", "1.93"},
             {"Total Fees", "$3.45"},
             {"Estimated Strategy Capacity", "$970000000.00"},
             {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},

Algorithm.CSharp/CustomUniverseWithBenchmarkRegressionAlgorithm.cs

@@ -189,8 +189,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Beta", "0"},
             {"Annual Standard Deviation", "0"},
             {"Annual Variance", "0"},
-            {"Information Ratio", "-2.564"},
-            {"Tracking Error", "0.214"},
+            {"Information Ratio", "-2.094"},
+            {"Tracking Error", "0.175"},
             {"Treynor Ratio", "0"},
             {"Total Fees", "$0.00"},
             {"Estimated Strategy Capacity", "$0"},

Algorithm.CSharp/CustomWarmUpPeriodIndicatorAlgorithm.cs

@@ -0,0 +1,202 @@
+/*
+ * 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.
+*/
+
+using System;
+using System.Collections.Generic;
+using QuantConnect.Data.Market;
+using QuantConnect.Interfaces;
+using QuantConnect.Indicators;
+using QuantConnect.Data;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Regression test to check custom indicators warms up properly
+    /// when one of them define WarmUpPeriod parameter and the other doesn't
+    /// </summary>
+    public class CustomWarmUpPeriodIndicatorAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private CustomSMA _customNotWarmUp;
+        private CSMAWithWarmUp _customWarmUp;
+
+        public override void Initialize()
+        {
+            SetStartDate(2013, 10, 7);
+            SetEndDate(2013, 10, 11);
+            AddEquity("SPY", Resolution.Second);
+
+            // Create two custom indicators, where one of them defines WarmUpPeriod parameter
+            _customNotWarmUp = new CustomSMA("_customNotWarmUp", 60);
+            _customWarmUp = new CSMAWithWarmUp("_customWarmUp", 60);
+
+            // Register the daily data of "SPY" to automatically update both indicators
+            RegisterIndicator("SPY", _customWarmUp, Resolution.Minute);
+            RegisterIndicator("SPY", _customNotWarmUp, Resolution.Minute);
+
+            // Warm up _customWarmUp indicator
+            WarmUpIndicator("SPY", _customWarmUp, Resolution.Minute);
+
+            // Check _customWarmUp indicator has already been warmed up with the requested data
+            if (!_customWarmUp.IsReady)
+            {
+                throw new Exception("_customWarmUp indicator was expected to be ready");
+            }
+            if (_customWarmUp.Samples != 60)
+            {
+                throw new Exception("_customWarmUp indicator was expected to have processed 60 datapoints already");
+            }
+
+            // Try to warm up _customNotWarmUp indicator. It's expected from LEAN to skip the warm up process
+            // because this indicator doesn't implement IIndicatorWarmUpPeriodProvider
+            WarmUpIndicator("SPY", _customNotWarmUp, Resolution.Minute);
+
+            // Check _customNotWarmUp indicator is not ready, because the warm up process was skipped
+            if (_customNotWarmUp.IsReady)
+            {
+                throw new Exception("_customNotWarmUp indicator wasn't expected to be warmed up");
+            }
+        }
+
+        public void OnData(TradeBars data)
+        {
+            if (!Portfolio.Invested)
+            {
+                SetHoldings("SPY", 1);
+            }
+
+            if (Time.Second == 0)
+            {
+                // Compute the difference between the indicators values
+                var diff = Math.Abs(_customNotWarmUp.Current.Value - _customWarmUp.Current.Value);
+
+                // Check _customNotWarmUp indicator is ready when the number of samples is bigger than its period
+                if (_customNotWarmUp.IsReady != (_customNotWarmUp.Samples >= 60))
+                {
+                    throw new Exception("_customNotWarmUp indicator was expected to be ready when the number of samples were bigger that its WarmUpPeriod parameter");
+                }
+
+                // Check their values are the same when both are ready
+                if (diff > 1e-10m && _customNotWarmUp.IsReady && _customWarmUp.IsReady) 
+                {
+                    throw new Exception($"The values of the indicators are not the same. The difference is {diff}");
+                }
+            }
+        }
+
+        /// <summary>
+        /// Custom implementation of SimpleMovingAverage.
+        /// Represents the traditional simple moving average indicator (SMA) without WarmUpPeriod parameter defined
+        /// </summary>
+        private class CustomSMA : IndicatorBase<IBaseData>
+        {
+            private Queue<IBaseData> _queue;
+            private int _period;
+            public CustomSMA(string name, int period)
+                : base(name)
+            {
+                _queue = new Queue<IBaseData>();
+                _period = period;
+            }
+
+            public override bool IsReady => _queue.Count == _period;
+
+            protected override decimal ComputeNextValue(IBaseData input)
+            {
+                _queue.Enqueue(input);
+                if (_queue.Count > _period)
+                {
+                    _queue.Dequeue();
+                }
+                var items = (_queue.ToArray());
+                var sum = 0m;
+                Array.ForEach(items, i => sum += i.Value);
+                return sum / _queue.Count;
+            }
+        }
+
+        /// <summary>
+        /// Custom implementation of SimpleMovingAverage.
+        /// Represents the traditional simple moving average indicator (SMA) with WarmUpPeriod defined
+        /// </summary>
+        private class CSMAWithWarmUp : CustomSMA, IIndicatorWarmUpPeriodProvider
+        {
+            public CSMAWithWarmUp(string name, int period)
+                : base(name, period)
+            {
+                WarmUpPeriod = period;
+            }
+            public int WarmUpPeriod { get; private set; }
+        }
+
+        /// <summary>
+        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
+        /// </summary>
+        public bool CanRunLocally { get; } = true;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public Language[] Languages { get; } = { Language.CSharp, Language.Python };
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        {
+            {"Total Trades", "1"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "272.157%"},
+            {"Drawdown", "2.200%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "1.694%"},
+            {"Sharpe Ratio", "8.897"},
+            {"Probabilistic Sharpe Ratio", "67.609%"},
+            {"Loss Rate", "0%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "-0.003"},
+            {"Beta", "0.998"},
+            {"Annual Standard Deviation", "0.222"},
+            {"Annual Variance", "0.049"},
+            {"Information Ratio", "-14.534"},
+            {"Tracking Error", "0.001"},
+            {"Treynor Ratio", "1.98"},
+            {"Total Fees", "$3.45"},
+            {"Estimated Strategy Capacity", "$310000000.00"},
+            {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
+            {"Fitness Score", "0.246"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "9.761"},
+            {"Return Over Maximum Drawdown", "107.509"},
+            {"Portfolio Turnover", "0.249"},
+            {"Total Insights Generated", "0"},
+            {"Total Insights Closed", "0"},
+            {"Total Insights Analysis Completed", "0"},
+            {"Long Insight Count", "0"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "$0"},
+            {"Total Accumulated Estimated Alpha Value", "$0"},
+            {"Mean Population Estimated Insight Value", "$0"},
+            {"Mean Population Direction", "0%"},
+            {"Mean Population Magnitude", "0%"},
+            {"Rolling Averaged Population Direction", "0%"},
+            {"Rolling Averaged Population Magnitude", "0%"},
+            {"OrderListHash", "e10039d74166b161f3ea2851a5e85843"}
+        };
+    }
+}

Algorithm.CSharp/DailyHistoryForDailyResolutionRegressionAlgorithm.cs

@@ -114,8 +114,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Beta", "0"},
             {"Annual Standard Deviation", "0"},
             {"Annual Variance", "0"},
-            {"Information Ratio", "-0.098"},
-            {"Tracking Error", "0.179"},
+            {"Information Ratio", "-0.101"},
+            {"Tracking Error", "0.185"},
             {"Treynor Ratio", "0"},
             {"Total Fees", "$0.00"},
             {"Estimated Strategy Capacity", "$0"},

Algorithm.CSharp/DailyHistoryForMinuteResolutionRegressionAlgorithm.cs

@@ -114,8 +114,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Beta", "0"},
             {"Annual Standard Deviation", "0"},
             {"Annual Variance", "0"},
-            {"Information Ratio", "-0.111"},
-            {"Tracking Error", "0.207"},
+            {"Information Ratio", "-0.104"},
+            {"Tracking Error", "0.192"},
             {"Treynor Ratio", "0"},
             {"Total Fees", "$0.00"},
             {"Estimated Strategy Capacity", "$0"},

Algorithm.CSharp/DelistedFutureLiquidateRegressionAlgorithm.cs

@@ -94,32 +94,32 @@ namespace QuantConnect.Algorithm.CSharp
         public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
             {"Total Trades", "2"},
-            {"Average Win", "1.63%"},
+            {"Average Win", "1.64%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "7.292%"},
+            {"Compounding Annual Return", "7.329%"},
             {"Drawdown", "1.300%"},
             {"Expectancy", "0"},
-            {"Net Profit", "1.634%"},
-            {"Sharpe Ratio", "2.495"},
-            {"Probabilistic Sharpe Ratio", "92.298%"},
+            {"Net Profit", "1.642%"},
+            {"Sharpe Ratio", "2.36"},
+            {"Probabilistic Sharpe Ratio", "94.555%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "100%"},
             {"Profit-Loss Ratio", "0"},
             {"Alpha", "0.006"},
-            {"Beta", "0.157"},
-            {"Annual Standard Deviation", "0.033"},
+            {"Beta", "0.158"},
+            {"Annual Standard Deviation", "0.03"},
             {"Annual Variance", "0.001"},
-            {"Information Ratio", "-4.901"},
-            {"Tracking Error", "0.081"},
-            {"Treynor Ratio", "0.519"},
-            {"Total Fees", "$3.70"},
+            {"Information Ratio", "-4.44"},
+            {"Tracking Error", "0.075"},
+            {"Treynor Ratio", "0.441"},
+            {"Total Fees", "$1.85"},
             {"Estimated Strategy Capacity", "$170000000.00"},
             {"Lowest Capacity Asset", "ES VMKLFZIH2MTD"},
             {"Fitness Score", "0.019"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "1.362"},
-            {"Return Over Maximum Drawdown", "9.699"},
+            {"Sortino Ratio", "1.369"},
+            {"Return Over Maximum Drawdown", "9.749"},
             {"Portfolio Turnover", "0.023"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
@@ -134,7 +134,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "00d6dc8775da38f7f79defad06de240a"}
+            {"OrderListHash", "4c5e32aedcd5bb67642d1629628fe615"}
         };
     }
 }

Algorithm.CSharp/DelistedIndexOptionDivestedRegression.cs

@@ -132,18 +132,18 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "45.600%"},
             {"Expectancy", "-1"},
             {"Net Profit", "-26.400%"},
-            {"Sharpe Ratio", "-0.557"},
-            {"Probabilistic Sharpe Ratio", "20.162%"},
+            {"Sharpe Ratio", "-0.602"},
+            {"Probabilistic Sharpe Ratio", "19.127%"},
             {"Loss Rate", "100%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "-0.564"},
-            {"Beta", "-0.663"},
-            {"Annual Standard Deviation", "1.752"},
-            {"Annual Variance", "3.069"},
-            {"Information Ratio", "-0.906"},
-            {"Tracking Error", "1.763"},
-            {"Treynor Ratio", "1.472"},
+            {"Alpha", "-0.559"},
+            {"Beta", "-0.807"},
+            {"Annual Standard Deviation", "1.582"},
+            {"Annual Variance", "2.502"},
+            {"Information Ratio", "-0.905"},
+            {"Tracking Error", "1.593"},
+            {"Treynor Ratio", "1.181"},
             {"Total Fees", "$0.00"},
             {"Estimated Strategy Capacity", "$1000000.00"},
             {"Lowest Capacity Asset", "SPX 31KC0UJFONTBI|SPX 31"},
@@ -166,7 +166,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "4ae4c1d8e4054c41908fd36e893699a6"}
+            {"OrderListHash", "721fddfd1327f7adcc2883d1412708c9"}
         };
     }
 }

Algorithm.CSharp/DelistingEventsAlgorithm.cs

@@ -140,34 +140,34 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
-            {"Total Trades", "3"},
+            {"Total Trades", "2"},
             {"Average Win", "0%"},
-            {"Average Loss", "-3.23%"},
-            {"Compounding Annual Return", "-79.990%"},
-            {"Drawdown", "4.300%"},
+            {"Average Loss", "-5.58%"},
+            {"Compounding Annual Return", "-87.694%"},
+            {"Drawdown", "5.600%"},
             {"Expectancy", "-1"},
-            {"Net Profit", "-4.312%"},
-            {"Sharpe Ratio", "-5.958"},
-            {"Probabilistic Sharpe Ratio", "0.000%"},
+            {"Net Profit", "-5.578%"},
+            {"Sharpe Ratio", "-4.683"},
+            {"Probabilistic Sharpe Ratio", "0.008%"},
             {"Loss Rate", "100%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "-0.685"},
-            {"Beta", "-0.445"},
-            {"Annual Standard Deviation", "0.119"},
-            {"Annual Variance", "0.014"},
-            {"Information Ratio", "-4.887"},
-            {"Tracking Error", "0.155"},
-            {"Treynor Ratio", "1.589"},
-            {"Total Fees", "$55.05"},
-            {"Estimated Strategy Capacity", "$43000.00"},
+            {"Alpha", "-0.622"},
+            {"Beta", "-0.877"},
+            {"Annual Standard Deviation", "0.142"},
+            {"Annual Variance", "0.02"},
+            {"Information Ratio", "-3.844"},
+            {"Tracking Error", "0.186"},
+            {"Treynor Ratio", "0.759"},
+            {"Total Fees", "$36.70"},
+            {"Estimated Strategy Capacity", "$65000.00"},
             {"Lowest Capacity Asset", "AAA SEVKGI6HF885"},
-            {"Fitness Score", "0.002"},
+            {"Fitness Score", "0.003"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "-15.687"},
-            {"Return Over Maximum Drawdown", "-18.549"},
-            {"Portfolio Turnover", "0.334"},
+            {"Sortino Ratio", "-10.959"},
+            {"Return Over Maximum Drawdown", "-15.72"},
+            {"Portfolio Turnover", "0.224"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
             {"Total Insights Analysis Completed", "0"},
@@ -181,7 +181,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "e357cfa77fd5e5b974c68d550fa66490"}
+            {"OrderListHash", "2d66947eafcca81ba9a2cd3bb351eee2"}
         };
     }
 }

Algorithm.CSharp/DelistingFutureOptionRegressionAlgorithm.cs

@@ -108,9 +108,9 @@ namespace QuantConnect.Algorithm.CSharp
             {"Average Loss", "-0.02%"},
             {"Compounding Annual Return", "-0.111%"},
             {"Drawdown", "0.100%"},
-            {"Expectancy", "-0.679"},
-            {"Net Profit", "-0.112%"},
-            {"Sharpe Ratio", "-1.052"},
+            {"Expectancy", "-0.678"},
+            {"Net Profit", "-0.111%"},
+            {"Sharpe Ratio", "-0.967"},
             {"Probabilistic Sharpe Ratio", "0.000%"},
             {"Loss Rate", "80%"},
             {"Win Rate", "20%"},
@@ -119,10 +119,10 @@ namespace QuantConnect.Algorithm.CSharp
             {"Beta", "-0.001"},
             {"Annual Standard Deviation", "0.001"},
             {"Annual Variance", "0"},
-            {"Information Ratio", "-1.182"},
-            {"Tracking Error", "0.117"},
-            {"Treynor Ratio", "1.617"},
-            {"Total Fees", "$37.00"},
+            {"Information Ratio", "-1.075"},
+            {"Tracking Error", "0.107"},
+            {"Treynor Ratio", "1.353"},
+            {"Total Fees", "$14.80"},
             {"Estimated Strategy Capacity", "$860000000.00"},
             {"Lowest Capacity Asset", "DC V5E8P9SH0U0X"},
             {"Fitness Score", "0"},
@@ -144,7 +144,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "de309ab56d2fcd80ff03df2802d9feda"}
+            {"OrderListHash", "d10e8665214344369e3e8f1c49dbdd67"}
         };
     }
 }

Algorithm.CSharp/DisplacedMovingAverageRibbon.cs

@@ -173,18 +173,18 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "12.400%"},
             {"Expectancy", "0"},
             {"Net Profit", "153.224%"},
-            {"Sharpe Ratio", "1.233"},
-            {"Probabilistic Sharpe Ratio", "65.906%"},
+            {"Sharpe Ratio", "1.116"},
+            {"Probabilistic Sharpe Ratio", "56.426%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "100%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "0.146"},
-            {"Beta", "-0.016"},
-            {"Annual Standard Deviation", "0.117"},
-            {"Annual Variance", "0.014"},
-            {"Information Ratio", "-0.052"},
-            {"Tracking Error", "0.204"},
-            {"Treynor Ratio", "-8.847"},
+            {"Alpha", "0.054"},
+            {"Beta", "0.507"},
+            {"Annual Standard Deviation", "0.107"},
+            {"Annual Variance", "0.011"},
+            {"Information Ratio", "-0.082"},
+            {"Tracking Error", "0.105"},
+            {"Treynor Ratio", "0.235"},
             {"Total Fees", "$49.43"},
             {"Estimated Strategy Capacity", "$740000000.00"},
             {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},

Algorithm.CSharp/DropboxBaseDataUniverseSelectionAlgorithm.cs

@@ -195,18 +195,18 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "10.400%"},
             {"Expectancy", "0.068"},
             {"Net Profit", "14.802%"},
-            {"Sharpe Ratio", "1.077"},
-            {"Probabilistic Sharpe Ratio", "50.578%"},
+            {"Sharpe Ratio", "0.978"},
+            {"Probabilistic Sharpe Ratio", "46.740%"},
             {"Loss Rate", "46%"},
             {"Win Rate", "54%"},
             {"Profit-Loss Ratio", "0.97"},
-            {"Alpha", "0.137"},
-            {"Beta", "-0.069"},
-            {"Annual Standard Deviation", "0.119"},
-            {"Annual Variance", "0.014"},
-            {"Information Ratio", "0.046"},
-            {"Tracking Error", "0.169"},
-            {"Treynor Ratio", "-1.869"},
+            {"Alpha", "0.008"},
+            {"Beta", "0.98"},
+            {"Annual Standard Deviation", "0.109"},
+            {"Annual Variance", "0.012"},
+            {"Information Ratio", "0.158"},
+            {"Tracking Error", "0.041"},
+            {"Treynor Ratio", "0.109"},
             {"Total Fees", "$7495.19"},
             {"Estimated Strategy Capacity", "$320000.00"},
             {"Lowest Capacity Asset", "BNO UN3IMQ2JU1YD"},

Algorithm.CSharp/DropboxUniverseSelectionAlgorithm.cs

@@ -168,18 +168,18 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "10.300%"},
             {"Expectancy", "0.081"},
             {"Net Profit", "16.153%"},
-            {"Sharpe Ratio", "1.17"},
-            {"Probabilistic Sharpe Ratio", "54.048%"},
+            {"Sharpe Ratio", "1.062"},
+            {"Probabilistic Sharpe Ratio", "50.224%"},
             {"Loss Rate", "45%"},
             {"Win Rate", "55%"},
             {"Profit-Loss Ratio", "0.97"},
-            {"Alpha", "0.147"},
-            {"Beta", "-0.068"},
-            {"Annual Standard Deviation", "0.119"},
-            {"Annual Variance", "0.014"},
-            {"Information Ratio", "0.11"},
-            {"Tracking Error", "0.169"},
-            {"Treynor Ratio", "-2.057"},
+            {"Alpha", "0.018"},
+            {"Beta", "0.979"},
+            {"Annual Standard Deviation", "0.109"},
+            {"Annual Variance", "0.012"},
+            {"Information Ratio", "0.38"},
+            {"Tracking Error", "0.041"},
+            {"Treynor Ratio", "0.118"},
             {"Total Fees", "$5869.25"},
             {"Estimated Strategy Capacity", "$320000.00"},
             {"Lowest Capacity Asset", "BNO UN3IMQ2JU1YD"},

Algorithm.CSharp/DuplicateSecurityWithBenchmarkRegressionAlgorithm.cs

@@ -106,8 +106,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Beta", "0"},
             {"Annual Standard Deviation", "0"},
             {"Annual Variance", "0"},
-            {"Information Ratio", "-7.163"},
-            {"Tracking Error", "0.195"},
+            {"Information Ratio", "-8.91"},
+            {"Tracking Error", "0.223"},
             {"Treynor Ratio", "0"},
             {"Total Fees", "$0.00"},
             {"Estimated Strategy Capacity", "$0"},

Algorithm.CSharp/DynamicSecurityDataRegressionAlgorithm.cs

@@ -107,18 +107,18 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "0.100%"},
             {"Expectancy", "0"},
             {"Net Profit", "0.618%"},
-            {"Sharpe Ratio", "9.975"},
-            {"Probabilistic Sharpe Ratio", "99.752%"},
+            {"Sharpe Ratio", "8.815"},
+            {"Probabilistic Sharpe Ratio", "99.065%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "0.23"},
-            {"Beta", "-0.031"},
+            {"Alpha", "0.12"},
+            {"Beta", "0.143"},
             {"Annual Standard Deviation", "0.022"},
             {"Annual Variance", "0"},
-            {"Information Ratio", "-2.899"},
-            {"Tracking Error", "0.101"},
-            {"Treynor Ratio", "-6.961"},
+            {"Information Ratio", "-3.746"},
+            {"Tracking Error", "0.084"},
+            {"Treynor Ratio", "1.349"},
             {"Total Fees", "$1.00"},
             {"Estimated Strategy Capacity", "$1000000000.00"},
             {"Lowest Capacity Asset", "GOOG T1AZ164W5VTX"},

Algorithm.CSharp/EmitInsightNoAlphaModelAlgorithm.cs

@@ -122,18 +122,18 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "2.900%"},
             {"Expectancy", "-1"},
             {"Net Profit", "-1.740%"},
-            {"Sharpe Ratio", "-2.982"},
-            {"Probabilistic Sharpe Ratio", "22.315%"},
+            {"Sharpe Ratio", "-2.985"},
+            {"Probabilistic Sharpe Ratio", "24.619%"},
             {"Loss Rate", "100%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "-0.387"},
-            {"Beta", "-0.138"},
-            {"Annual Standard Deviation", "0.195"},
-            {"Annual Variance", "0.038"},
-            {"Information Ratio", "-6.727"},
-            {"Tracking Error", "0.294"},
-            {"Treynor Ratio", "4.201"},
+            {"Alpha", "1.316"},
+            {"Beta", "-0.998"},
+            {"Annual Standard Deviation", "0.222"},
+            {"Annual Variance", "0.049"},
+            {"Information Ratio", "-5.951"},
+            {"Tracking Error", "0.445"},
+            {"Treynor Ratio", "0.664"},
             {"Total Fees", "$20.23"},
             {"Estimated Strategy Capacity", "$520000000.00"},
             {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},

Algorithm.CSharp/EmitInsightsAlgorithm.cs

@@ -114,18 +114,18 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "1.200%"},
             {"Expectancy", "-0.021"},
             {"Net Profit", "-0.873%"},
-            {"Sharpe Ratio", "-2.308"},
-            {"Probabilistic Sharpe Ratio", "31.792%"},
+            {"Sharpe Ratio", "-2.39"},
+            {"Probabilistic Sharpe Ratio", "33.387%"},
             {"Loss Rate", "50%"},
             {"Win Rate", "50%"},
             {"Profit-Loss Ratio", "0.96"},
-            {"Alpha", "-0.675"},
-            {"Beta", "0.232"},
-            {"Annual Standard Deviation", "0.152"},
-            {"Annual Variance", "0.023"},
-            {"Information Ratio", "-8.38"},
-            {"Tracking Error", "0.209"},
-            {"Treynor Ratio", "-1.514"},
+            {"Alpha", "-1.646"},
+            {"Beta", "0.62"},
+            {"Annual Standard Deviation", "0.175"},
+            {"Annual Variance", "0.031"},
+            {"Information Ratio", "-17.555"},
+            {"Tracking Error", "0.137"},
+            {"Treynor Ratio", "-0.674"},
             {"Total Fees", "$17.19"},
             {"Estimated Strategy Capacity", "$640000000.00"},
             {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},

Algorithm.CSharp/EqualWeightingPortfolioConstructionModelFutureRegressionAlgorithm.cs

@@ -139,18 +139,18 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "29.500%"},
             {"Expectancy", "-1"},
             {"Net Profit", "-7.888%"},
-            {"Sharpe Ratio", "-0.612"},
-            {"Probabilistic Sharpe Ratio", "34.280%"},
+            {"Sharpe Ratio", "-0.593"},
+            {"Probabilistic Sharpe Ratio", "34.346%"},
             {"Loss Rate", "100%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "-13.93"},
-            {"Beta", "6.525"},
-            {"Annual Standard Deviation", "1.619"},
-            {"Annual Variance", "2.62"},
-            {"Information Ratio", "-2.091"},
-            {"Tracking Error", "1.422"},
-            {"Treynor Ratio", "-0.152"},
+            {"Alpha", "-15.391"},
+            {"Beta", "7.259"},
+            {"Annual Standard Deviation", "1.679"},
+            {"Annual Variance", "2.818"},
+            {"Information Ratio", "-2.032"},
+            {"Tracking Error", "1.466"},
+            {"Treynor Ratio", "-0.137"},
             {"Total Fees", "$40.70"},
             {"Estimated Strategy Capacity", "$4000000.00"},
             {"Lowest Capacity Asset", "GC VL5E74HP3EE5"},

Algorithm.CSharp/EquityTradeAndQuotesRegressionAlgorithm.cs

@@ -171,18 +171,18 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "3.300%"},
             {"Expectancy", "-0.225"},
             {"Net Profit", "-2.705%"},
-            {"Sharpe Ratio", "-4.958"},
-            {"Probabilistic Sharpe Ratio", "1.087%"},
+            {"Sharpe Ratio", "-5.022"},
+            {"Probabilistic Sharpe Ratio", "1.586%"},
             {"Loss Rate", "65%"},
             {"Win Rate", "35%"},
             {"Profit-Loss Ratio", "1.20"},
-            {"Alpha", "-1.401"},
-            {"Beta", "0.525"},
-            {"Annual Standard Deviation", "0.135"},
-            {"Annual Variance", "0.018"},
-            {"Information Ratio", "-16.23"},
-            {"Tracking Error", "0.127"},
-            {"Treynor Ratio", "-1.27"},
+            {"Alpha", "-1.879"},
+            {"Beta", "0.571"},
+            {"Annual Standard Deviation", "0.149"},
+            {"Annual Variance", "0.022"},
+            {"Information Ratio", "-22.181"},
+            {"Tracking Error", "0.123"},
+            {"Treynor Ratio", "-1.31"},
             {"Total Fees", "$670.68"},
             {"Estimated Strategy Capacity", "$190000.00"},
             {"Lowest Capacity Asset", "IBM R735QTJ8XC9X"},

Algorithm.CSharp/ExtendedMarketHoursHistoryRegressionAlgorithm.cs

@@ -134,18 +134,18 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "2.500%"},
             {"Expectancy", "-1"},
             {"Net Profit", "-1.040%"},
-            {"Sharpe Ratio", "-8.265"},
+            {"Sharpe Ratio", "-9.302"},
             {"Probabilistic Sharpe Ratio", "0%"},
             {"Loss Rate", "100%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "-0.187"},
-            {"Beta", "0.585"},
-            {"Annual Standard Deviation", "0.065"},
-            {"Annual Variance", "0.004"},
-            {"Information Ratio", "1.345"},
-            {"Tracking Error", "0.048"},
-            {"Treynor Ratio", "-0.925"},
+            {"Alpha", "-0.283"},
+            {"Beta", "0.55"},
+            {"Annual Standard Deviation", "0.075"},
+            {"Annual Variance", "0.006"},
+            {"Information Ratio", "0.914"},
+            {"Tracking Error", "0.061"},
+            {"Treynor Ratio", "-1.267"},
             {"Total Fees", "$21.45"},
             {"Estimated Strategy Capacity", "$830000.00"},
             {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},

Algorithm.CSharp/ExtendedMarketTradingRegressionAlgorithm.cs

@@ -109,18 +109,18 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "0.100%"},
             {"Expectancy", "0"},
             {"Net Profit", "0.100%"},
-            {"Sharpe Ratio", "7.449"},
-            {"Probabilistic Sharpe Ratio", "85.066%"},
+            {"Sharpe Ratio", "8.342"},
+            {"Probabilistic Sharpe Ratio", "83.750%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "0.006"},
+            {"Alpha", "0"},
             {"Beta", "0.033"},
-            {"Annual Standard Deviation", "0.007"},
+            {"Annual Standard Deviation", "0.008"},
             {"Annual Variance", "0"},
-            {"Information Ratio", "-7.131"},
-            {"Tracking Error", "0.189"},
-            {"Treynor Ratio", "1.576"},
+            {"Information Ratio", "-8.908"},
+            {"Tracking Error", "0.215"},
+            {"Treynor Ratio", "1.992"},
             {"Total Fees", "$4.00"},
             {"Estimated Strategy Capacity", "$6000000.00"},
             {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},

Algorithm.CSharp/FillForwardEnumeratorOutOfOrderBarRegressionAlgorithm.cs

@@ -81,21 +81,21 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "1"},
             {"Average Win", "0%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "0%"},
-            {"Drawdown", "0%"},
+            {"Compounding Annual Return", "16.086%"},
+            {"Drawdown", "0.100%"},
             {"Expectancy", "0"},
-            {"Net Profit", "0%"},
-            {"Sharpe Ratio", "0"},
+            {"Net Profit", "0.148%"},
+            {"Sharpe Ratio", "9.758"},
             {"Probabilistic Sharpe Ratio", "0%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
             {"Alpha", "0"},
             {"Beta", "0"},
-            {"Annual Standard Deviation", "0"},
+            {"Annual Standard Deviation", "0.014"},
             {"Annual Variance", "0"},
-            {"Information Ratio", "0"},
-            {"Tracking Error", "0"},
+            {"Information Ratio", "9.758"},
+            {"Tracking Error", "0.014"},
             {"Treynor Ratio", "0"},
             {"Total Fees", "$5.93"},
             {"Estimated Strategy Capacity", "$150000.00"},

Algorithm.CSharp/FineFundamentalFilteredUniverseRegressionAlgorithm.cs

@@ -92,18 +92,18 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "0.300%"},
             {"Expectancy", "0"},
             {"Net Profit", "1.947%"},
-            {"Sharpe Ratio", "14.546"},
-            {"Probabilistic Sharpe Ratio", "90.065%"},
+            {"Sharpe Ratio", "21.391"},
+            {"Probabilistic Sharpe Ratio", "0%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "2.13"},
-            {"Beta", "-0.467"},
-            {"Annual Standard Deviation", "0.165"},
-            {"Annual Variance", "0.027"},
-            {"Information Ratio", "7.676"},
-            {"Tracking Error", "0.389"},
-            {"Treynor Ratio", "-5.146"},
+            {"Alpha", "4.505"},
+            {"Beta", "0.567"},
+            {"Annual Standard Deviation", "0.192"},
+            {"Annual Variance", "0.037"},
+            {"Information Ratio", "30.843"},
+            {"Tracking Error", "0.156"},
+            {"Treynor Ratio", "7.25"},
             {"Total Fees", "$22.30"},
             {"Estimated Strategy Capacity", "$250000000.00"},
             {"Lowest Capacity Asset", "AAPL R735QTJ8XC9X"},

Algorithm.CSharp/ForexInternalFeedOnDataHigherResolutionRegressionAlgorithm.cs

@@ -149,8 +149,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Beta", "0"},
             {"Annual Standard Deviation", "0"},
             {"Annual Variance", "0"},
-            {"Information Ratio", "5.865"},
-            {"Tracking Error", "0.106"},
+            {"Information Ratio", "5.91"},
+            {"Tracking Error", "0.13"},
             {"Treynor Ratio", "0"},
             {"Total Fees", "$0.00"},
             {"Estimated Strategy Capacity", "$0"},

Algorithm.CSharp/ForexInternalFeedOnDataSameResolutionRegressionAlgorithm.cs

@@ -153,8 +153,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Beta", "0"},
             {"Annual Standard Deviation", "0"},
             {"Annual Variance", "0"},
-            {"Information Ratio", "5.865"},
-            {"Tracking Error", "0.106"},
+            {"Information Ratio", "5.91"},
+            {"Tracking Error", "0.13"},
             {"Treynor Ratio", "0"},
             {"Total Fees", "$0.00"},
             {"Estimated Strategy Capacity", "$0"},

Algorithm.CSharp/FractionalQuantityRegressionAlgorithm.cs

@@ -101,21 +101,21 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "6"},
             {"Average Win", "6.02%"},
             {"Average Loss", "-2.40%"},
-            {"Compounding Annual Return", "915.480%"},
+            {"Compounding Annual Return", "1497.266%"},
             {"Drawdown", "5.500%"},
             {"Expectancy", "1.338"},
-            {"Net Profit", "11.400%"},
-            {"Sharpe Ratio", "9.507"},
-            {"Probabilistic Sharpe Ratio", "76.768%"},
+            {"Net Profit", "13.775%"},
+            {"Sharpe Ratio", "3.309"},
+            {"Probabilistic Sharpe Ratio", "61.758%"},
             {"Loss Rate", "33%"},
             {"Win Rate", "67%"},
             {"Profit-Loss Ratio", "2.51"},
             {"Alpha", "0"},
             {"Beta", "0"},
-            {"Annual Standard Deviation", "0.507"},
-            {"Annual Variance", "0.257"},
-            {"Information Ratio", "9.507"},
-            {"Tracking Error", "0.507"},
+            {"Annual Standard Deviation", "0.379"},
+            {"Annual Variance", "0.144"},
+            {"Information Ratio", "3.309"},
+            {"Tracking Error", "0.379"},
             {"Treynor Ratio", "0"},
             {"Total Fees", "$2651.01"},
             {"Estimated Strategy Capacity", "$30000.00"},
@@ -139,7 +139,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "2b3ac55337ce5619fc0388ccdac72c54"}
+            {"OrderListHash", "604291218c630343a896bfa2f3104932"}
         };
     }
 }

Algorithm.CSharp/FreePortfolioValueRegressionAlgorithm.cs

@@ -86,18 +86,18 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "55.000%"},
             {"Expectancy", "-1"},
             {"Net Profit", "125.420%"},
-            {"Sharpe Ratio", "0.469"},
-            {"Probabilistic Sharpe Ratio", "2.603%"},
+            {"Sharpe Ratio", "0.427"},
+            {"Probabilistic Sharpe Ratio", "1.166%"},
             {"Loss Rate", "100%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "0.092"},
-            {"Beta", "-0.091"},
-            {"Annual Standard Deviation", "0.179"},
-            {"Annual Variance", "0.032"},
-            {"Information Ratio", "-0.001"},
-            {"Tracking Error", "0.265"},
-            {"Treynor Ratio", "-0.927"},
+            {"Alpha", "-0"},
+            {"Beta", "0.997"},
+            {"Annual Standard Deviation", "0.164"},
+            {"Annual Variance", "0.027"},
+            {"Information Ratio", "-0.213"},
+            {"Tracking Error", "0.001"},
+            {"Treynor Ratio", "0.07"},
             {"Total Fees", "$43.46"},
             {"Estimated Strategy Capacity", "$430000000.00"},
             {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},

Algorithm.CSharp/FutureOptionBuySellCallIntradayRegressionAlgorithm.cs

@@ -119,32 +119,32 @@ namespace QuantConnect.Algorithm.CSharp
         public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
             {"Total Trades", "6"},
-            {"Average Win", "2.93%"},
+            {"Average Win", "2.94%"},
             {"Average Loss", "-4.15%"},
-            {"Compounding Annual Return", "-5.673%"},
-            {"Drawdown", "5.700%"},
-            {"Expectancy", "-0.148"},
-            {"Net Profit", "-2.802%"},
-            {"Sharpe Ratio", "-0.49"},
-            {"Probabilistic Sharpe Ratio", "10.317%"},
+            {"Compounding Annual Return", "-5.589%"},
+            {"Drawdown", "5.600%"},
+            {"Expectancy", "-0.145"},
+            {"Net Profit", "-2.760%"},
+            {"Sharpe Ratio", "-0.45"},
+            {"Probabilistic Sharpe Ratio", "9.306%"},
             {"Loss Rate", "50%"},
             {"Win Rate", "50%"},
-            {"Profit-Loss Ratio", "0.70"},
-            {"Alpha", "-0.042"},
+            {"Profit-Loss Ratio", "0.71"},
+            {"Alpha", "-0.036"},
             {"Beta", "-0.012"},
-            {"Annual Standard Deviation", "0.087"},
-            {"Annual Variance", "0.007"},
-            {"Information Ratio", "-0.162"},
-            {"Tracking Error", "0.418"},
-            {"Treynor Ratio", "3.493"},
-            {"Total Fees", "$14.80"},
-            {"Estimated Strategy Capacity", "$180000000.00"},
-            {"Lowest Capacity Asset", "ES XFH59UK0MYO1"},
+            {"Annual Standard Deviation", "0.08"},
+            {"Annual Variance", "0.006"},
+            {"Information Ratio", "-0.149"},
+            {"Tracking Error", "0.387"},
+            {"Treynor Ratio", "2.943"},
+            {"Total Fees", "$3.70"},
+            {"Estimated Strategy Capacity", "$280000000.00"},
+            {"Lowest Capacity Asset", "ES XFH59UPBIJ7O|ES XFH59UK0MYO1"},
             {"Fitness Score", "0.017"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "-0.097"},
-            {"Return Over Maximum Drawdown", "-1.002"},
+            {"Sortino Ratio", "-0.096"},
+            {"Return Over Maximum Drawdown", "-0.993"},
             {"Portfolio Turnover", "0.043"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
@@ -159,7 +159,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "fc9eb9b0a644e4890d5ec3d40367d0e1"}
+            {"OrderListHash", "18f8a17034aa12be40581baecca96788"}
         };
     }
 }

Algorithm.CSharp/FutureOptionCallITMExpiryRegressionAlgorithm.cs

@@ -126,7 +126,7 @@ namespace QuantConnect.Algorithm.CSharp
 
         private void AssertFutureOptionOrderExercise(OrderEvent orderEvent, Security future, Security optionContract)
         {
-            var expectedLiquidationTimeUtc = new DateTime(2020, 6, 19, 20, 0, 0);
+            var expectedLiquidationTimeUtc = new DateTime(2020, 6, 20, 4, 0, 0);
 
             if (orderEvent.Direction == OrderDirection.Sell && future.Holdings.Quantity != 0)
             {
@@ -203,27 +203,27 @@ namespace QuantConnect.Algorithm.CSharp
         public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
             {"Total Trades", "3"},
-            {"Average Win", "1.22%"},
-            {"Average Loss", "-7.42%"},
-            {"Compounding Annual Return", "-12.482%"},
+            {"Average Win", "1.26%"},
+            {"Average Loss", "-7.41%"},
+            {"Compounding Annual Return", "-12.424%"},
             {"Drawdown", "6.300%"},
-            {"Expectancy", "-0.417"},
-            {"Net Profit", "-6.282%"},
-            {"Sharpe Ratio", "-1.316"},
-            {"Probabilistic Sharpe Ratio", "0.004%"},
+            {"Expectancy", "-0.415"},
+            {"Net Profit", "-6.252%"},
+            {"Sharpe Ratio", "-1.226"},
+            {"Probabilistic Sharpe Ratio", "0.002%"},
             {"Loss Rate", "50%"},
             {"Win Rate", "50%"},
             {"Profit-Loss Ratio", "0.17"},
-            {"Alpha", "-0.1"},
+            {"Alpha", "-0.086"},
             {"Beta", "0.004"},
-            {"Annual Standard Deviation", "0.076"},
-            {"Annual Variance", "0.006"},
-            {"Information Ratio", "-0.305"},
-            {"Tracking Error", "0.411"},
-            {"Treynor Ratio", "-27.616"},
-            {"Total Fees", "$7.40"},
-            {"Estimated Strategy Capacity", "$180000000.00"},
-            {"Lowest Capacity Asset", "ES XFH59UK0MYO1"},
+            {"Annual Standard Deviation", "0.07"},
+            {"Annual Variance", "0.005"},
+            {"Information Ratio", "-0.283"},
+            {"Tracking Error", "0.379"},
+            {"Treynor Ratio", "-23.811"},
+            {"Total Fees", "$1.85"},
+            {"Estimated Strategy Capacity", "$270000000.00"},
+            {"Lowest Capacity Asset", "ES XFH59UPBIJ7O|ES XFH59UK0MYO1"},
             {"Fitness Score", "0.008"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
@@ -243,7 +243,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "c59d790b89d76f1ad3bb7738b28567c9"}
+            {"OrderListHash", "b738fdaf1dae6849884df9e51eb6482b"}
         };
     }
 }

Algorithm.CSharp/FutureOptionCallITMGreeksExpiryRegressionAlgorithm.cs

@@ -168,32 +168,32 @@ namespace QuantConnect.Algorithm.CSharp
         public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
             {"Total Trades", "3"},
-            {"Average Win", "8.71%"},
-            {"Average Loss", "-34.89%"},
-            {"Compounding Annual Return", "-50.850%"},
-            {"Drawdown", "29.200%"},
-            {"Expectancy", "-0.375"},
-            {"Net Profit", "-29.224%"},
-            {"Sharpe Ratio", "-1.025"},
-            {"Probabilistic Sharpe Ratio", "0.019%"},
+            {"Average Win", "8.93%"},
+            {"Average Loss", "-34.88%"},
+            {"Compounding Annual Return", "-50.632%"},
+            {"Drawdown", "29.100%"},
+            {"Expectancy", "-0.372"},
+            {"Net Profit", "-29.072%"},
+            {"Sharpe Ratio", "-0.978"},
+            {"Probabilistic Sharpe Ratio", "0.012%"},
             {"Loss Rate", "50%"},
             {"Win Rate", "50%"},
-            {"Profit-Loss Ratio", "0.25"},
-            {"Alpha", "-0.387"},
+            {"Profit-Loss Ratio", "0.26"},
+            {"Alpha", "-0.339"},
             {"Beta", "0.017"},
-            {"Annual Standard Deviation", "0.377"},
-            {"Annual Variance", "0.142"},
-            {"Information Ratio", "-0.751"},
-            {"Tracking Error", "0.548"},
-            {"Treynor Ratio", "-22.299"},
-            {"Total Fees", "$37.00"},
-            {"Estimated Strategy Capacity", "$33000000.00"},
-            {"Lowest Capacity Asset", "ES XFH59UK0MYO1"},
-            {"Fitness Score", "0.056"},
+            {"Annual Standard Deviation", "0.347"},
+            {"Annual Variance", "0.12"},
+            {"Information Ratio", "-0.714"},
+            {"Tracking Error", "0.505"},
+            {"Treynor Ratio", "-19.672"},
+            {"Total Fees", "$9.25"},
+            {"Estimated Strategy Capacity", "$50000000.00"},
+            {"Lowest Capacity Asset", "ES XFH59UPBIJ7O|ES XFH59UK0MYO1"},
+            {"Fitness Score", "0.055"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
             {"Sortino Ratio", "-0.155"},
-            {"Return Over Maximum Drawdown", "-1.741"},
+            {"Return Over Maximum Drawdown", "-1.743"},
             {"Portfolio Turnover", "0.152"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
@@ -208,7 +208,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "ca0898608da51d972723b1065a3f0d47"}
+            {"OrderListHash", "ed0cbd8487dd45519e5d0225e51ba29c"}
         };
     }
 }

Algorithm.CSharp/FutureOptionCallOTMExpiryRegressionAlgorithm.cs

@@ -179,24 +179,24 @@ namespace QuantConnect.Algorithm.CSharp
         {
             {"Total Trades", "2"},
             {"Average Win", "0%"},
-            {"Average Loss", "-4.03%"},
-            {"Compounding Annual Return", "-8.103%"},
+            {"Average Loss", "-4.02%"},
+            {"Compounding Annual Return", "-8.099%"},
             {"Drawdown", "4.000%"},
             {"Expectancy", "-1"},
-            {"Net Profit", "-4.029%"},
-            {"Sharpe Ratio", "-1.266"},
-            {"Probabilistic Sharpe Ratio", "0.015%"},
+            {"Net Profit", "-4.027%"},
+            {"Sharpe Ratio", "-1.175"},
+            {"Probabilistic Sharpe Ratio", "0.009%"},
             {"Loss Rate", "100%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "-0.065"},
+            {"Alpha", "-0.056"},
             {"Beta", "0.002"},
-            {"Annual Standard Deviation", "0.051"},
-            {"Annual Variance", "0.003"},
-            {"Information Ratio", "-0.222"},
-            {"Tracking Error", "0.408"},
-            {"Treynor Ratio", "-27.32"},
-            {"Total Fees", "$3.70"},
+            {"Annual Standard Deviation", "0.047"},
+            {"Annual Variance", "0.002"},
+            {"Information Ratio", "-0.206"},
+            {"Tracking Error", "0.376"},
+            {"Treynor Ratio", "-23.481"},
+            {"Total Fees", "$1.85"},
             {"Estimated Strategy Capacity", "$200000000.00"},
             {"Lowest Capacity Asset", "ES XFH59UPHGV9G|ES XFH59UK0MYO1"},
             {"Fitness Score", "0"},
@@ -218,7 +218,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "5dc2591837f882d173d2d4852b3b0626"}
+            {"OrderListHash", "cf1c12b839e49456dc2793f0e63c7803"}
         };
     }
 }

Algorithm.CSharp/FutureOptionDailyRegressionAlgorithm.cs

@@ -0,0 +1,169 @@
+/*
+ * 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.
+*/
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using QuantConnect.Data;
+using QuantConnect.Interfaces;
+using QuantConnect.Orders;
+using QuantConnect.Securities;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// This regression algorithm tests using FutureOptions daily resolution
+    /// </summary>
+    public class FutureOptionDailyRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        protected OrderTicket Ticket;
+        protected Symbol DcOption;
+        protected virtual Resolution Resolution => Resolution.Daily;
+        
+        public override void Initialize()
+        {
+            SetStartDate(2012, 1, 3);
+            SetEndDate(2012, 1, 4);
+
+            // Add our underlying future contract
+            var dc = AddFutureContract(
+                QuantConnect.Symbol.CreateFuture(
+                    Futures.Dairy.ClassIIIMilk,
+                    Market.CME,
+                    new DateTime(2012, 4, 1)),
+                Resolution).Symbol;
+
+            // Attempt to fetch a specific future option contract
+            DcOption = OptionChainProvider.GetOptionContractList(dc, Time)
+                .Where(x => x.ID.StrikePrice == 17m && x.ID.OptionRight == OptionRight.Call)
+                .Select(x => AddFutureOptionContract(x, Resolution).Symbol)
+                .FirstOrDefault();
+            
+            // Validate it is the expected contract
+            var expectedContract = QuantConnect.Symbol.CreateOption(dc, Market.CME, OptionStyle.American,
+                OptionRight.Call, 17m,
+                new DateTime(2012, 4, 01));
+            
+            if (DcOption != expectedContract)
+            {
+                throw new Exception($"Contract {DcOption} was not the expected contract {expectedContract}");
+            }
+            
+            ScheduleBuySell();
+        }
+        
+        protected virtual void ScheduleBuySell()
+        {
+            // Schedule a purchase of this contract tomorrow at 1AM
+            Schedule.On(DateRules.Tomorrow, TimeRules.At(1,0,0), () =>
+            {
+                Ticket = MarketOrder(DcOption, 1);
+            });
+            
+            // Schedule liquidation tomorrow at 6PM
+            Schedule.On(DateRules.Tomorrow, TimeRules.At(18,0,0), () =>
+            {
+                Liquidate();
+            });
+        }
+
+        public override void OnData(Slice slice)
+        {
+            // Assert we are only getting data at 7PM (12AM UTC)
+            if (slice.Time.Hour != 19)
+            {
+                throw new ArgumentException($"Expected data at 7PM each day; instead was {slice.Time}");
+            }
+        }
+
+        /// <summary>
+        /// Ran at the end of the algorithm to ensure the algorithm has no holdings
+        /// </summary>
+        /// <exception cref="Exception">The algorithm has holdings</exception>
+        public override void OnEndOfAlgorithm()
+        {
+            if (Portfolio.Invested)
+            {
+                throw new Exception($"Expected no holdings at end of algorithm, but are invested in: {string.Join(", ", Portfolio.Keys)}");
+            }
+            
+            if (Ticket.Status != OrderStatus.Filled)
+            {
+                throw new Exception("Future option order failed to fill correctly");
+            }
+        }
+
+        /// <summary>
+        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
+        /// </summary>
+        public virtual bool CanRunLocally { get; } = true;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public virtual Language[] Languages { get; } = { Language.CSharp, Language.Python };
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public virtual Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        {
+            {"Total Trades", "2"},
+            {"Average Win", "0%"},
+            {"Average Loss", "-0.82%"},
+            {"Compounding Annual Return", "-66.089%"},
+            {"Drawdown", "0.800%"},
+            {"Expectancy", "-1"},
+            {"Net Profit", "-0.824%"},
+            {"Sharpe Ratio", "-6.993"},
+            {"Probabilistic Sharpe Ratio", "0%"},
+            {"Loss Rate", "100%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "0.466"},
+            {"Beta", "-7.501"},
+            {"Annual Standard Deviation", "0.092"},
+            {"Annual Variance", "0.009"},
+            {"Information Ratio", "-7.586"},
+            {"Tracking Error", "0.105"},
+            {"Treynor Ratio", "0.086"},
+            {"Total Fees", "$3.70"},
+            {"Estimated Strategy Capacity", "$0"},
+            {"Lowest Capacity Asset", "DC V5E8P9VAH3IC|DC V5E8P9SH0U0X"},
+            {"Fitness Score", "0.006"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "79228162514264337593543950335"},
+            {"Return Over Maximum Drawdown", "-80.233"},
+            {"Portfolio Turnover", "0.013"},
+            {"Total Insights Generated", "0"},
+            {"Total Insights Closed", "0"},
+            {"Total Insights Analysis Completed", "0"},
+            {"Long Insight Count", "0"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "$0"},
+            {"Total Accumulated Estimated Alpha Value", "$0"},
+            {"Mean Population Estimated Insight Value", "$0"},
+            {"Mean Population Direction", "0%"},
+            {"Mean Population Magnitude", "0%"},
+            {"Rolling Averaged Population Direction", "0%"},
+            {"Rolling Averaged Population Magnitude", "0%"},
+            {"OrderListHash", "f00013930ab4c104a6177485d8090b31"}
+        };
+    }
+}
+