Removes extra day added to CBOE Time causing data to shift one day forward (#5266)

* Added test

.github/workflows/gh-actions.yml

@@ -0,0 +1,31 @@
+name: Build & Test Lean
+
+on:
+  push:
+    branches: ['*']
+  pull_request:
+    branches: [master]
+
+jobs:
+  build:
+    runs-on: ubuntu-16.04
+    container:
+        image: quantconnect/lean:foundation
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Restore nuget dependencies
+        run: |
+          nuget restore QuantConnect.Lean.sln -v quiet
+          nuget install NUnit.Runners -Version 3.11.1 -OutputDirectory testrunner
+
+      - name: Build
+        run: msbuild /p:Configuration=Release /p:VbcToolExe=vbnc.exe /v:quiet /p:WarningLevel=1 QuantConnect.Lean.sln
+
+      - name: Run Tests
+        run: mono ./testrunner/NUnit.ConsoleRunner.3.11.1/tools/nunit3-console.exe ./Tests/bin/Release/QuantConnect.Tests.dll --where "cat != TravisExclude" --labels=Off --params:log-handler=ConsoleErrorLogHandler
+
+      - name: Generate & Publish python stubs
+        run: |
+          chmod +x ci_build_stubs.sh
+          ./ci_build_stubs.sh -d -t -g #Ignore Publish as of since credentials are missing on CI

.gitignore

@@ -144,6 +144,7 @@ $tf/
 # ReSharper is a .NET coding add-in
 _ReSharper*/
 *.[Rr]e[Ss]harper
+*.DotSettings
 *.DotSettings.user
 
 # JustCode is a .NET coding addin-in
@@ -271,3 +272,6 @@ QuantConnect.Lean.sln.DotSettings*
 
 #User notebook files
 Research/Notebooks
+
+#Docker result files
+Results/

.idea/Lean.iml

@@ -1,18 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module type="PYTHON_MODULE" version="4">
-  <component name="NewModuleRootManager">
-    <content url="file://$MODULE_DIR$">
-      <sourceFolder url="file://$MODULE_DIR$/Algorithm.Python" isTestSource="false" />
-      <sourceFolder url="file://$MODULE_DIR$/Algorithm.Python/stubs" isTestSource="false" />
-    </content>
-    <orderEntry type="inheritedJdk" />
-    <orderEntry type="sourceFolder" forTests="false" />
-  </component>
-  <component name="PyDocumentationSettings">
-    <option name="format" value="PLAIN" />
-    <option name="myDocStringFormat" value="Plain" />
-  </component>
-  <component name="TestRunnerService">
-    <option name="PROJECT_TEST_RUNNER" value="pytest" />
-  </component>
-</module>

.idea/readme.md

@@ -91,14 +91,14 @@ From a terminal; Pycharm has a built in terminal on the bottom taskbar labeled *
 
  2. Using the **run_docker.cfg** to store args for repeated use; any blank entries will resort to default values! example: **_./run_docker.bat run_docker.cfg_**
   
-        image=quantconnect/lean:latest
-        config_file=
-        data_dir=
-        results_dir=
-        debugging=
-        python_dir=
+        IMAGE=quantconnect/lean:latest
+        CONFIG_FILE=
+        DATA_DIR=
+        RESULTS_DIR=
+        DEBUGGING=
+        PYTHON_DIR=
 
- 3. Inline arguments; anything you don't enter will use the default args! example: **_./run_docker.bat debugging=y_** 
+ 3. Inline arguments; anything you don't enter will use the default args! example: **_./run_docker.bat DEBUGGING=y_** 
       *    Accepted args for inline include all listed in the file in #2; must follow the **key=value** format
 
 <br />

.idea/workspace.xml

@@ -3,7 +3,7 @@
   <component name="RunManager" selected="Python Debug Server.Debug in Container">
     <configuration name="Debug Local" type="PyRemoteDebugConfigurationType" factoryName="Python Remote Debug">
       <module name="LEAN" />
-      <option name="PORT" value="5678" />
+      <option name="PORT" value="6000" />
       <option name="HOST" value="localhost" />
       <PathMappingSettings>
         <option name="pathMappings">
@@ -16,7 +16,7 @@
     </configuration>
     <configuration name="Debug in Container" type="PyRemoteDebugConfigurationType" factoryName="Python Remote Debug">
       <module name="LEAN" />
-      <option name="PORT" value="5678" />
+      <option name="PORT" value="6000" />
       <option name="HOST" value="localhost" />
       <PathMappingSettings>
         <option name="pathMappings">

.travis.yml

@@ -5,7 +5,7 @@ mono:
 solution: QuantConnect.Lean.sln
 before_install:
   - export PATH="$HOME/miniconda3/bin:$PATH"
-  - wget https://cdn.quantconnect.com/miniconda/Miniconda3-4.5.12-Linux-x86_64.sh
+  - wget -q https://cdn.quantconnect.com/miniconda/Miniconda3-4.5.12-Linux-x86_64.sh
   - bash Miniconda3-4.5.12-Linux-x86_64.sh -b
   - rm -rf Miniconda3-4.5.12-Linux-x86_64.sh
   - sudo ln -s $HOME/miniconda3/lib/libpython3.6m.so /usr/lib/libpython3.6m.so
@@ -17,10 +17,10 @@ before_install:
   - conda install -y scipy=1.4.1
   - conda install -y wrapt=1.12.1
 install:
-  - nuget restore QuantConnect.Lean.sln
+  - nuget restore QuantConnect.Lean.sln -v quiet
   - nuget install NUnit.Runners -Version 3.11.1 -OutputDirectory testrunner
 script:
-  - msbuild /p:Configuration=Release /p:VbcToolExe=vbnc.exe QuantConnect.Lean.sln
-  - mono ./testrunner/NUnit.ConsoleRunner.3.11.1/tools/nunit3-console.exe ./Tests/bin/Release/QuantConnect.Tests.dll --where "cat != TravisExclude" --labels=Off
+  - msbuild /p:Configuration=Release /p:VbcToolExe=vbnc.exe /v:quiet /p:WarningLevel=1 QuantConnect.Lean.sln
+  - mono ./testrunner/NUnit.ConsoleRunner.3.11.1/tools/nunit3-console.exe ./Tests/bin/Release/QuantConnect.Tests.dll --where "cat != TravisExclude" --labels=Off --params:log-handler=ConsoleErrorLogHandler
   - chmod +x ci_build_stubs.sh
-  - sudo -E ./ci_build_stubs.sh -ipy -g -p
+  - sudo -E ./ci_build_stubs.sh -d -t -g -p

.vs/readme.md

@@ -106,14 +106,14 @@ From a terminal launch the run_docker.bat/.sh script; there are a few choices on
 
  2. Using the **run_docker.cfg** to store args for repeated use; any blank entries will resort to default values! example: **_./run_docker.bat run_docker.cfg_**
   
-        image=quantconnect/lean:latest
-        config_file=
-        data_dir=
-        results_dir=
-        debugging=
-        python_dir=
+        IMAGE=quantconnect/lean:latest
+        CONFIG_FILE=
+        DATA_DIR=
+        RESULTS_DIR=
+        DEBUGGING=
+        PYTHON_DIR=
 
- 3. Inline arguments; anything you don't enter will use the default args! example: **_./run_docker.bat debugging=y_** 
+ 3. Inline arguments; anything you don't enter will use the default args! example: **_./run_docker.bat DEBUGGING=y_** 
       *    Accepted args for inline include all listed in the file in #2
 
 <br />

.vscode/readme.md

@@ -13,7 +13,7 @@ Before anything we need to ensure a few things have been done:
 
 
 1. Get [Visual Studio Code](https://code.visualstudio.com/download)
-    *   Get the Extension [Mono Debug](https://marketplace.visualstudio.com/items?itemName=ms-vscode.mono-debug) for C# Debugging
+    *   Get the Extension [Mono Debug **15.8**](https://marketplace.visualstudio.com/items?itemName=ms-vscode.mono-debug) for C# Debugging
     *   Get the Extension [Python](https://marketplace.visualstudio.com/items?itemName=ms-python.python) for Python Debugging
 
 2. Get [Docker](https://docs.docker.com/get-docker/):
@@ -35,7 +35,8 @@ Before anything we need to ensure a few things have been done:
     *   Download the repo or clone it using: _git clone[ https://github.com/QuantConnect/Lean](https://github.com/QuantConnect/Lean)_
     *   Open the folder using VS Code
 
-
+**NOTES**: 
+- Mono Extension Version 16 and greater fails to debug the docker container remotely, please install **Version 15.8**. To install an older version from within VS Code go to the extensions tab, search "Mono Debug", and select "Install Another Version...".
 <br />
 
 <h1>Develop Algorithms Locally, Run in Container</h1>
@@ -101,17 +102,23 @@ This section will cover how to actually launch Lean in the container with your d
 
 <h3>Option 1 (Recommended)</h3>
 
-In VS Code click on the debug/run icon on the left toolbar, at the top you should see a drop down menu with launch options, be sure to select **Debug in Container**. This option will kick off a launch script that will start the docker. With this specific launch option the parameters are already configured in VS Codes **tasks.json** under the **run-docker** task args. These set arguements are:
+In VS Code click on the debug/run icon on the left toolbar, at the top you should see a drop down menu with launch options, be sure to select **Debug in Container**. This option will kick off a launch script that will start the docker. With this specific launch option the parameters are already configured in VS Codes **tasks.json** under the **run-docker** task args. These set arguments are:
 
-    "image=quantconnect/lean:latest",
-    "config_file=${workspaceFolder}/Launcher/config.json",
-    "data_dir=${workspaceFolder}/Data",
-    "results_dir=${workspaceFolder}/",
-    "debugging=Y",
-    "python_location=${workspaceFolder}/Algorithm.Python"
+    "IMAGE=quantconnect/lean:latest",
+    "CONFIG_FILE=${workspaceFolder}/Launcher/config.json",
+    "DATA_DIR=${workspaceFolder}/Data",
+    "RESULTS_DIR=${workspaceFolder}/Results",
+    "DEBUGGING=Y",
+    "PYHTON_DIR=${workspaceFolder}/Algorithm.Python"
 
 As defaults these are all great! Feel free to change them as needed for your setup.
 
+**NOTE:** VSCode may try and throw errors when launching this way regarding build on `QuantConnect.csx` and `Config.json` these errors can be ignored by selecting "*Debug Anyway*". To stop this error message in the future select "*Remember my choice in user settings*". 
+
+If using C# algorithms ensure that msbuild can build them successfully.  
+
+
+
 <br />
 
 <h3>Option 2</h3>
@@ -120,21 +127,21 @@ From a terminal launch the run_docker.bat/.sh script; there are a few choices on
  1. Launch with no parameters and answer the questions regarding configuration (Press enter for defaults)
    
         *   Enter docker image [default: quantconnect/lean:latest]:
-        *   Enter absolute path to Lean config file [default: _~currentDir_\Launcher\config.json]:
-        *   Enter absolute path to Data folder [default: ~_currentDir_\Data\]:
-        *   Enter absolute path to store results [default: ~_currentDir_\]:
+        *   Enter absolute path to Lean config file [default: .\Launcher\config.json]:
+        *   Enter absolute path to Data folder [default: .\Data\]:
+        *   Enter absolute path to store results [default: .\Results]:
         *   Would you like to debug C#? (Requires mono debugger attachment) [default: N]:
 
  2. Using the **run_docker.cfg** to store args for repeated use; any blank entries will resort to default values! example: **_./run_docker.bat run_docker.cfg_**
   
-        image=quantconnect/lean:latest
-        config_file=
-        data_dir=
-        results_dir=
-        debugging=
-        python_dir=
+        IMAGE=quantconnect/lean:latest
+        CONFIG_FILE=
+        DATA_DIR=
+        RESULTS_DIR=
+        DEBUGGING=
+        PYTHON_DIR=
 
- 3. Inline arguments; anything you don't enter will use the default args! example: **_./run_docker.bat debugging=y_** 
+ 3. Inline arguments; anything you don't enter will use the default args! example: **_./run_docker.bat DEBUGGING=y_** 
       *    Accepted args for inline include all listed in the file in #2
 
 <br />
@@ -194,4 +201,6 @@ _Figure 2: Python Debugger Messages_
 <h1>Common Issues</h1>
 Here we will cover some common issues with setting this up. This section will expand as we get user feedback!
 
-*   Error messages about build in VSCode points to comments in JSON. Either select **ignore** or follow steps described [here](https://stackoverflow.com/questions/47834825/in-vs-code-disable-error-comments-are-not-permitted-in-json) to remove the errors entirely.
+*   Any error messages about building in VSCode that point to comments in JSON. Either select **ignore** or follow steps described [here](https://stackoverflow.com/questions/47834825/in-vs-code-disable-error-comments-are-not-permitted-in-json) to remove the errors entirely.
+*   `Errors exist after running preLaunchTask 'run-docker'`This VSCode error appears to warn you of CSharp errors when trying to use `Debug in Container` select "Debug Anyway" as the errors are false flags for JSON comments as well as `QuantConnect.csx` not finding references. Neither of these will impact your debugging. 
+*   `The container name "/LeanEngine" is already in use by container "****"` This Docker error implies that another instance of lean is already running under the container name /LeanEngine. If this error appears either use Docker Desktop to delete the container or use `docker kill LeanEngine` from the command line.

.vscode/settings.json

@@ -1,5 +0,0 @@
-{
-    "python.autoComplete.extraPaths": [
-        "Algorithm.Python/stubs"
-    ]
-}

.vscode/tasks.json

@@ -20,6 +20,34 @@
             },
             "problemMatcher": "$msCompile"
         },
+        {
+            "label": "rebuild",
+            "type": "shell",
+            "command": "msbuild",
+            "args": [
+                "/p:Configuration=Debug",
+                "/p:DebugType=portable",
+                "/t:rebuild",
+            ],
+            "group": "build",
+            "presentation": {
+                "reveal": "silent"
+            },
+            "problemMatcher": "$msCompile"
+        },
+        {
+            "label": "clean",
+            "type": "shell",
+            "command": "msbuild",
+            "args": [
+                "/t:clean",
+            ],
+            "group": "build",
+            "presentation": {
+                "reveal": "silent"
+            },
+            "problemMatcher": "$msCompile"
+        },
         {
             "label": "force build linux",
             "type": "shell",
@@ -51,13 +79,13 @@
                 "command": "${workspaceFolder}/run_docker.sh"
             },
             "args": [
-                "image=quantconnect/lean:latest",
-                "config_file=${workspaceFolder}/Launcher/config.json",
-                "data_dir=${workspaceFolder}/Data",
-                "results_dir=${workspaceFolder}/",
-                "debugging=Y",
-                "python_dir=${workspaceFolder}/Algorithm.Python",
-                "exit=Y"
+                "IMAGE=quantconnect/lean:latest",
+                "CONFIG_FILE=${workspaceFolder}/Launcher/config.json",
+                "DATA_DIR=${workspaceFolder}/Data",
+                "RESULTS_DIR=${workspaceFolder}/Results",
+                "DEBUGGING=Y",
+                "PYTHON_DIR=${workspaceFolder}/Algorithm.Python",
+                "EXIT=Y"
             ],
             "problemMatcher": [
                 {

Algorithm.CSharp/AddFutureOptionContractDataStreamingRegressionAlgorithm.cs

@@ -0,0 +1,210 @@
+/*
+ * 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.Interfaces;
+using QuantConnect.Securities;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// This regression algorithm tests that we receive the expected data when
+    /// we add future option contracts individually using <see cref="AddFutureOptionContract"/>
+    /// </summary>
+    public class AddFutureOptionContractDataStreamingRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private bool _onDataReached;
+        private bool _invested;
+        private Symbol _es20h20;
+        private Symbol _es19m20;
+
+        private readonly HashSet<Symbol> _symbolsReceived = new HashSet<Symbol>();
+        private readonly HashSet<Symbol> _expectedSymbolsReceived = new HashSet<Symbol>();
+        private readonly Dictionary<Symbol, List<QuoteBar>> _dataReceived = new Dictionary<Symbol, List<QuoteBar>>();
+
+        public override void Initialize()
+        {
+            SetStartDate(2020, 1, 5);
+            SetEndDate(2020, 1, 6);
+
+            _es20h20 = AddFutureContract(
+                QuantConnect.Symbol.CreateFuture(Futures.Indices.SP500EMini, Market.CME, new DateTime(2020, 3, 20)),
+                Resolution.Minute).Symbol;
+
+            _es19m20 = AddFutureContract(
+                QuantConnect.Symbol.CreateFuture(Futures.Indices.SP500EMini, Market.CME, new DateTime(2020, 6, 19)),
+                Resolution.Minute).Symbol;
+
+            var optionChains = OptionChainProvider.GetOptionContractList(_es20h20, Time)
+                .Concat(OptionChainProvider.GetOptionContractList(_es19m20, Time));
+
+            foreach (var optionContract in optionChains)
+            {
+                _expectedSymbolsReceived.Add(AddFutureOptionContract(optionContract, Resolution.Minute).Symbol);
+            }
+
+            if (_expectedSymbolsReceived.Count == 0)
+            {
+                throw new InvalidOperationException("Expected Symbols receive count is 0, expected >0");
+            }
+        }
+
+        public override void OnData(Slice data)
+        {
+            if (!data.HasData)
+            {
+                return;
+            }
+
+            _onDataReached = true;
+
+            var hasOptionQuoteBars = false;
+            foreach (var qb in data.QuoteBars.Values)
+            {
+                if (qb.Symbol.SecurityType != SecurityType.FutureOption)
+                {
+                    continue;
+                }
+
+                hasOptionQuoteBars = true;
+
+                _symbolsReceived.Add(qb.Symbol);
+                if (!_dataReceived.ContainsKey(qb.Symbol))
+                {
+                    _dataReceived[qb.Symbol] = new List<QuoteBar>();
+                }
+
+                _dataReceived[qb.Symbol].Add(qb);
+            }
+
+            if (_invested || !hasOptionQuoteBars)
+            {
+                return;
+            }
+
+            if (data.ContainsKey(_es20h20) && data.ContainsKey(_es19m20))
+            {
+                SetHoldings(_es20h20, 0.2);
+                SetHoldings(_es19m20, 0.2);
+
+                _invested = true;
+            }
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            base.OnEndOfAlgorithm();
+
+            if (!_onDataReached)
+            {
+                throw new Exception("OnData() was never called.");
+            }
+            if (_symbolsReceived.Count != _expectedSymbolsReceived.Count)
+            {
+                throw new AggregateException($"Expected {_expectedSymbolsReceived.Count} option contracts Symbols, found {_symbolsReceived.Count}");
+            }
+
+            var missingSymbols = new List<Symbol>();
+            foreach (var expectedSymbol in _expectedSymbolsReceived)
+            {
+                if (!_symbolsReceived.Contains(expectedSymbol))
+                {
+                    missingSymbols.Add(expectedSymbol);
+                }
+            }
+
+            if (missingSymbols.Count > 0)
+            {
+                throw new Exception($"Symbols: \"{string.Join(", ", missingSymbols)}\" were not found in OnData");
+            }
+
+            foreach (var expectedSymbol in _expectedSymbolsReceived)
+            {
+                var data = _dataReceived[expectedSymbol];
+                var nonDupeDataCount = data.Select(x =>
+                {
+                    x.EndTime = default(DateTime);
+                    return x;
+                }).Distinct().Count();
+
+                if (nonDupeDataCount < 1000)
+                {
+                    throw new Exception($"Received too few data points. Expected >=1000, found {nonDupeDataCount} for {expectedSymbol}");
+                }
+            }
+        }
+
+        /// <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%"},
+            {"Compounding Annual Return", "217.585%"},
+            {"Drawdown", "0.600%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "0.635%"},
+            {"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", "-14.395"},
+            {"Tracking Error", "0.043"},
+            {"Treynor Ratio", "0"},
+            {"Total Fees", "$7.40"},
+            {"Fitness Score", "1"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "79228162514264337593543950335"},
+            {"Return Over Maximum Drawdown", "79228162514264337593543950335"},
+            {"Portfolio Turnover", "3.199"},
+            {"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", "1074366800"}
+        };
+    }
+}

Algorithm.CSharp/AddFutureOptionSingleOptionChainSelectedInUniverseFilterRegressionAlgorithm.cs

@@ -0,0 +1,244 @@
+/*
+ * 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.Interfaces;
+using QuantConnect.Securities;
+using QuantConnect.Securities.Future;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// This regression algorithm tests that we only receive the option chain for a single future contract
+    /// in the option universe filter.
+    /// </summary>
+    public class AddFutureOptionSingleOptionChainSelectedInUniverseFilterRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private bool _invested;
+        private bool _onDataReached;
+        private bool _optionFilterRan;
+        private readonly HashSet<Symbol> _symbolsReceived = new HashSet<Symbol>();
+        private readonly HashSet<Symbol> _expectedSymbolsReceived = new HashSet<Symbol>();
+        private readonly Dictionary<Symbol, List<QuoteBar>> _dataReceived = new Dictionary<Symbol, List<QuoteBar>>();
+
+        private Future _es;
+
+        public override void Initialize()
+        {
+            SetStartDate(2020, 1, 5);
+            SetEndDate(2020, 1, 6);
+
+            _es = AddFuture(Futures.Indices.SP500EMini, Resolution.Minute, Market.CME);
+            _es.SetFilter((futureFilter) =>
+            {
+                return futureFilter.Expiration(0, 365).ExpirationCycle(new[] { 3, 6 });
+            });
+
+            AddFutureOption(_es.Symbol, optionContracts =>
+            {
+                _optionFilterRan = true;
+
+                var expiry = new HashSet<DateTime>(optionContracts.Select(x => x.Underlying.ID.Date)).SingleOrDefault();
+                // Cast to IEnumerable<Symbol> because OptionFilterContract overrides some LINQ operators like `Select` and `Where`
+                // and cause it to mutate the underlying Symbol collection when using those operators.
+                var symbol = new HashSet<Symbol>(((IEnumerable<Symbol>)optionContracts).Select(x => x.Underlying)).SingleOrDefault();
+
+                if (expiry == null || symbol == null)
+                {
+                    throw new InvalidOperationException("Expected a single Option contract in the chain, found 0 contracts");
+                }
+
+                var enumerator = optionContracts.GetEnumerator();
+                while (enumerator.MoveNext())
+                {
+                    _expectedSymbolsReceived.Add(enumerator.Current);
+                }
+
+                return optionContracts;
+            });
+        }
+
+        public override void OnData(Slice data)
+        {
+            if (!data.HasData)
+            {
+                return;
+            }
+
+            _onDataReached = true;
+
+            var hasOptionQuoteBars = false;
+            foreach (var qb in data.QuoteBars.Values)
+            {
+                if (qb.Symbol.SecurityType != SecurityType.FutureOption)
+                {
+                    continue;
+                }
+
+                hasOptionQuoteBars = true;
+
+                _symbolsReceived.Add(qb.Symbol);
+                if (!_dataReceived.ContainsKey(qb.Symbol))
+                {
+                    _dataReceived[qb.Symbol] = new List<QuoteBar>();
+                }
+
+                _dataReceived[qb.Symbol].Add(qb);
+            }
+
+            if (_invested || !hasOptionQuoteBars)
+            {
+                return;
+            }
+
+            foreach (var chain in data.OptionChains.Values)
+            {
+                var futureInvested = false;
+                var optionInvested = false;
+
+                foreach (var option in chain.Contracts.Keys)
+                {
+                    if (futureInvested && optionInvested)
+                    {
+                        return;
+                    }
+
+                    var future = option.Underlying;
+
+                    if (!optionInvested && data.ContainsKey(option))
+                    {
+                        MarketOrder(option, 1);
+                        _invested = true;
+                        optionInvested = true;
+                    }
+                    if (!futureInvested && data.ContainsKey(future))
+                    {
+                        MarketOrder(future, 1);
+                        _invested = true;
+                        futureInvested = true;
+                    }
+                }
+            }
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            base.OnEndOfAlgorithm();
+
+            if (!_optionFilterRan)
+            {
+                throw new InvalidOperationException("Option chain filter was never ran");
+            }
+            if (!_onDataReached)
+            {
+                throw new Exception("OnData() was never called.");
+            }
+            if (_symbolsReceived.Count != _expectedSymbolsReceived.Count)
+            {
+                throw new AggregateException($"Expected {_expectedSymbolsReceived.Count} option contracts Symbols, found {_symbolsReceived.Count}");
+            }
+
+            var missingSymbols = new List<Symbol>();
+            foreach (var expectedSymbol in _expectedSymbolsReceived)
+            {
+                if (!_symbolsReceived.Contains(expectedSymbol))
+                {
+                    missingSymbols.Add(expectedSymbol);
+                }
+            }
+
+            if (missingSymbols.Count > 0)
+            {
+                throw new Exception($"Symbols: \"{string.Join(", ", missingSymbols)}\" were not found in OnData");
+            }
+
+            foreach (var expectedSymbol in _expectedSymbolsReceived)
+            {
+                var data = _dataReceived[expectedSymbol];
+                var nonDupeDataCount = data.Select(x =>
+                {
+                    x.EndTime = default(DateTime);
+                    return x;
+                }).Distinct().Count();
+
+                if (nonDupeDataCount < 1000)
+                {
+                    throw new Exception($"Received too few data points. Expected >=1000, found {nonDupeDataCount} for {expectedSymbol}");
+                }
+            }
+        }
+
+        /// <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%"},
+            {"Compounding Annual Return", "-15.625%"},
+            {"Drawdown", "0.200%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "-0.093%"},
+            {"Sharpe Ratio", "-11.181"},
+            {"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"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "-14.343"},
+            {"Tracking Error", "0.044"},
+            {"Treynor Ratio", "0.479"},
+            {"Total Fees", "$3.70"},
+            {"Fitness Score", "0.41"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "79228162514264337593543950335"},
+            {"Return Over Maximum Drawdown", "-185.654"},
+            {"Portfolio Turnover", "0.821"},
+            {"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", "1532330301"}
+        };
+    }
+}

Algorithm.CSharp/AddOptionContractExpiresRegressionAlgorithm.cs

@@ -131,13 +131,13 @@ namespace QuantConnect.Algorithm.CSharp
             {"Loss Rate", "50%"},
             {"Win Rate", "50%"},
             {"Profit-Loss Ratio", "0.92"},
-            {"Alpha", "-0.023"},
-            {"Beta", "0.005"},
+            {"Alpha", "-0.021"},
+            {"Beta", "-0.01"},
             {"Annual Standard Deviation", "0.006"},
             {"Annual Variance", "0"},
-            {"Information Ratio", "-3.424"},
-            {"Tracking Error", "0.057"},
-            {"Treynor Ratio", "-4.775"},
+            {"Information Ratio", "-3.374"},
+            {"Tracking Error", "0.058"},
+            {"Treynor Ratio", "2.133"},
             {"Total Fees", "$2.00"},
             {"Fitness Score", "0"},
             {"Kelly Criterion Estimate", "0"},
@@ -158,7 +158,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "-1185639451"}
+            {"OrderListHash", "-262924291"}
         };
     }
 }

Algorithm.CSharp/AllShortableSymbolsCoarseSelectionRegressionAlgorithm.cs

@@ -0,0 +1,236 @@
+/*
+ * 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.Brokerages;
+using QuantConnect.Data;
+using QuantConnect.Data.Shortable;
+using QuantConnect.Data.UniverseSelection;
+using QuantConnect.Interfaces;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Tests filtering in coarse selection by shortable quantity
+    /// </summary>
+    public class AllShortableSymbolsCoarseSelectionRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private static readonly DateTime _20140325 = new DateTime(2014, 3, 25);
+        private static readonly DateTime _20140326 = new DateTime(2014, 3, 26);
+        private static readonly DateTime _20140327 = new DateTime(2014, 3, 27);
+        private static readonly DateTime _20140328 = new DateTime(2014, 3, 28);
+        private static readonly DateTime _20140329 = new DateTime(2014, 3, 29);
+
+        private static readonly Symbol _aapl = QuantConnect.Symbol.Create("AAPL", SecurityType.Equity, Market.USA);
+        private static readonly Symbol _bac = QuantConnect.Symbol.Create("BAC", SecurityType.Equity, Market.USA);
+        private static readonly Symbol _gme = QuantConnect.Symbol.Create("GME", SecurityType.Equity, Market.USA);
+        private static readonly Symbol _goog = QuantConnect.Symbol.Create("GOOG", SecurityType.Equity, Market.USA);
+        private static readonly Symbol _qqq = QuantConnect.Symbol.Create("QQQ", SecurityType.Equity, Market.USA);
+        private static readonly Symbol _spy = QuantConnect.Symbol.Create("SPY", SecurityType.Equity, Market.USA);
+        private DateTime _lastTradeDate;
+
+        private static readonly Dictionary<DateTime, bool> _coarseSelected = new Dictionary<DateTime, bool>
+        {
+            { _20140325, false },
+            { _20140326, false },
+            { _20140327, false },
+            { _20140328, false },
+        };
+
+        private static readonly Dictionary<DateTime, Symbol[]> _expectedSymbols = new Dictionary<DateTime, Symbol[]>
+        {
+            { _20140325, new[]
+                {
+                    _bac,
+                    _qqq,
+                    _spy
+                }
+            },
+            { _20140326, new[]
+                {
+                    _spy
+                }
+            },
+            { _20140327, new[]
+                {
+                    _aapl,
+                    _bac,
+                    _gme,
+                    _qqq,
+                    _spy,
+                }
+            },
+            { _20140328, new[]
+                {
+                    _goog
+                }
+            },
+            { _20140329, new Symbol[0] }
+        };
+
+        public override void Initialize()
+        {
+            SetStartDate(2014, 3, 25);
+            SetEndDate(2014, 3, 29);
+            SetCash(10000000);
+
+            AddUniverse(CoarseSelection);
+            UniverseSettings.Resolution = Resolution.Daily;
+
+            SetBrokerageModel(new AllShortableSymbolsRegressionAlgorithmBrokerageModel());
+        }
+
+        public override void OnData(Slice data)
+        {
+            if (Time.Date == _lastTradeDate)
+            {
+                return;
+            }
+
+            foreach (var symbol in ActiveSecurities.Keys)
+            {
+                if (!Portfolio.ContainsKey(symbol) || !Portfolio[symbol].Invested)
+                {
+                    if (!Shortable(symbol))
+                    {
+                        throw new Exception($"Expected {symbol} to be shortable on {Time:yyyy-MM-dd}");
+                    }
+
+                    // Buy at least once into all Symbols. Since daily data will always use
+                    // MOO orders, it makes the testing of liquidating buying into Symbols difficult.
+                    MarketOrder(symbol, -(decimal)ShortableQuantity(symbol));
+                    _lastTradeDate = Time.Date;
+                }
+            }
+        }
+
+        private IEnumerable<Symbol> CoarseSelection(IEnumerable<CoarseFundamental> coarse)
+        {
+            var shortableSymbols = AllShortableSymbols();
+            var selectedSymbols = coarse
+                .Select(x => x.Symbol)
+                .Where(s => shortableSymbols.ContainsKey(s) && shortableSymbols[s] >= 500)
+                .OrderBy(s => s)
+                .ToList();
+
+            var expectedMissing = 0;
+            if (Time.Date == _20140327)
+            {
+                var gme = QuantConnect.Symbol.Create("GME", SecurityType.Equity, Market.USA);
+                if (!shortableSymbols.ContainsKey(gme))
+                {
+                    throw new Exception("Expected unmapped GME in shortable symbols list on 2014-03-27");
+                }
+                if (!coarse.Select(x => x.Symbol.Value).Contains("GME"))
+                {
+                    throw new Exception("Expected mapped GME in coarse symbols on 2014-03-27");
+                }
+
+                expectedMissing = 1;
+            }
+
+            var missing = _expectedSymbols[Time.Date].Except(selectedSymbols).ToList();
+            if (missing.Count != expectedMissing)
+            {
+                throw new Exception($"Expected Symbols selected on {Time.Date:yyyy-MM-dd} to match expected Symbols, but the following Symbols were missing: {string.Join(", ", missing.Select(s => s.ToString()))}");
+            }
+
+            _coarseSelected[Time.Date] = true;
+            return selectedSymbols;
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            if (!_coarseSelected.Values.All(x => x))
+            {
+                throw new AggregateException($"Expected coarse selection on all dates, but didn't run on: {string.Join(", ", _coarseSelected.Where(kvp => !kvp.Value).Select(kvp => kvp.Key.ToStringInvariant("yyyy-MM-dd")))}");
+            }
+        }
+
+        private class AllShortableSymbolsRegressionAlgorithmBrokerageModel : DefaultBrokerageModel
+        {
+            public AllShortableSymbolsRegressionAlgorithmBrokerageModel() : base()
+            {
+                ShortableProvider = new RegressionTestShortableProvider();
+            }
+        }
+
+        private class RegressionTestShortableProvider : LocalDiskShortableProvider
+        {
+            public RegressionTestShortableProvider() : base(SecurityType.Equity, "testbrokerage", Market.USA)
+            {
+            }
+        }
+
+        /// <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", "5"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "36.294%"},
+            {"Drawdown", "0%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "0.340%"},
+            {"Sharpe Ratio", "21.2"},
+            {"Probabilistic Sharpe Ratio", "99.990%"},
+            {"Loss Rate", "0%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "0.274"},
+            {"Beta", "0.138"},
+            {"Annual Standard Deviation", "0.011"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "7.202"},
+            {"Tracking Error", "0.068"},
+            {"Treynor Ratio", "1.722"},
+            {"Total Fees", "$307.50"},
+            {"Fitness Score", "0.173"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "79228162514264337593543950335"},
+            {"Return Over Maximum Drawdown", "79228162514264337593543950335"},
+            {"Portfolio Turnover", "0.173"},
+            {"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", "97613274"}
+        };
+    }
+}

Algorithm.CSharp/Alphas/MortgageRateVolatilityAlpha.cs

@@ -19,28 +19,27 @@ using QuantConnect.Indicators;
 using QuantConnect.Orders.Fees;
 using QuantConnect.Data.Custom;
 using System.Collections.Generic;
-using QuantConnect.Algorithm.Framework;
 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
+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
+    ///<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 : QCAlgorithmFramework
+    ///</summary>
+    public class MortgageRateVolatilityAlgorithm : QCAlgorithm
     {
         public override void Initialize()
         {
@@ -51,8 +50,8 @@ namespace QuantConnect.Algorithm.CSharp
             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();
+            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));
@@ -64,8 +63,6 @@ namespace QuantConnect.Algorithm.CSharp
             SetRiskManagement(new NullRiskManagementModel());
 
         }
-        
-        public void OnData(QuandlMortgagePriceColumns data) {  }
 
         private class MortgageRateVolatilityAlphaModel : AlphaModel
         {
@@ -79,7 +76,7 @@ namespace QuantConnect.Algorithm.CSharp
             private readonly StandardDeviation _mortgageRateStd;
 
             public MortgageRateVolatilityAlphaModel(
-                QCAlgorithmFramework algorithm,
+                QCAlgorithm algorithm,
                 int indicatorPeriod = 15,
                 double insightMagnitude = 0.0005,
                 int deviations = 2,
@@ -102,7 +99,7 @@ namespace QuantConnect.Algorithm.CSharp
                 WarmUpIndicators(algorithm);
             }
             
-            public override IEnumerable<Insight> Update(QCAlgorithmFramework algorithm, Slice data)
+            public override IEnumerable<Insight> Update(QCAlgorithm algorithm, Slice data)
             {
                 var insights = new List<Insight>();
                 
@@ -141,7 +138,7 @@ namespace QuantConnect.Algorithm.CSharp
                 return insights;
             }
 
-            private void WarmUpIndicators(QCAlgorithmFramework algorithm)
+            private void WarmUpIndicators(QCAlgorithm algorithm)
             {
             	// Make a history call and update the indicators
                 algorithm.History(new[] { _mortgageRate }, _indicatorPeriod, _resolution).PushThrough(bar =>

Algorithm.CSharp/AltData/QuiverWallStreetBetsDataAlgorithm.cs

@@ -0,0 +1,62 @@
+/*
+ * 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.Linq;
+using QuantConnect.Data;
+using QuantConnect.Data.Custom.Quiver;
+
+namespace QuantConnect.Algorithm.CSharp.AltData
+{
+    /// <summary>
+    /// Quiver Quantitative is a provider of alternative data.
+    /// This algorithm shows how to consume the <see cref="QuiverWallStreetBets"/>
+    /// </summary>
+    public class QuiverWallStreetBetsDataAlgorithm : QCAlgorithm
+    {
+        /// <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(2019, 1, 1);
+            SetEndDate(2020, 6, 1);
+            SetCash(100000);
+
+            var aapl = AddEquity("AAPL", Resolution.Daily).Symbol;
+            var quiverWSBSymbol = AddData<QuiverWallStreetBets>(aapl).Symbol;
+            var history = History<QuiverWallStreetBets>(quiverWSBSymbol, 60, Resolution.Daily);
+
+            Debug($"We got {history.Count()} items from our history request");
+        }
+
+        public override void OnData(Slice data)
+        {
+            var points = data.Get<QuiverWallStreetBets>();
+            foreach (var point in points.Values)
+            {
+                // Go long in the stock if it was mentioned more than 5 times in the WallStreetBets daily discussion
+                if (point.Mentions > 5)
+                {
+                    SetHoldings(point.Symbol.Underlying, 1);
+                }
+                // Go short in the stock if it was mentioned less than 5 times in the WallStreetBets daily discussion
+                if (point.Mentions < 5)
+                {
+                    SetHoldings(point.Symbol.Underlying, -1);
+                }
+            }
+        }
+    }
+}

Algorithm.CSharp/AutoRegressiveIntegratedMovingAverageRegressionAlgorithm.cs

@@ -0,0 +1,123 @@
+/*
+ * 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;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Regression algorithm to test the behaviour of ARMA versus AR models at the same order of differencing.
+    /// In particular, an ARIMA(1,1,1) and ARIMA(1,1,0) are instantiated while orders are placed if their difference
+    /// is sufficiently large (which would be due to the inclusion of the MA(1) term).
+    /// </summary>
+    public class AutoRegressiveIntegratedMovingAverageRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private AutoRegressiveIntegratedMovingAverage _arima;
+        private AutoRegressiveIntegratedMovingAverage _ar;
+        private decimal _last;
+
+        public override void Initialize()
+        {
+            SetStartDate(2013, 1, 07);
+            SetEndDate(2013, 12, 11);
+
+            EnableAutomaticIndicatorWarmUp = true;
+            AddEquity("SPY", Resolution.Daily);
+            _arima = ARIMA("SPY", 1, 1, 1, 50);
+            _ar = ARIMA("SPY", 1, 1, 0, 50);
+        }
+
+        public override void OnData(Slice slice)
+        {
+            if (_arima.IsReady)
+            {
+                if (Math.Abs(_ar.Current.Value - _arima.Current.Value) > 1) // Difference due to MA(1) being included.
+                {
+                    if (_arima.Current.Value > _last)
+                    {
+                        MarketOrder("SPY", 1);
+                    }
+                    else
+                    {
+                        MarketOrder("SPY", -1);
+                    }
+                }
+
+                _last = _arima.Current.Value;
+            }
+        }
+
+        /// <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", "65"},
+            {"Average Win", "0.00%"},
+            {"Average Loss", "0.00%"},
+            {"Compounding Annual Return", "0.145%"},
+            {"Drawdown", "0.100%"},
+            {"Expectancy", "2.190"},
+            {"Net Profit", "0.134%"},
+            {"Sharpe Ratio", "0.993"},
+            {"Probabilistic Sharpe Ratio", "49.669%"},
+            {"Loss Rate", "29%"},
+            {"Win Rate", "71%"},
+            {"Profit-Loss Ratio", "3.50"},
+            {"Alpha", "0.001"},
+            {"Beta", "0"},
+            {"Annual Standard Deviation", "0.001"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "-2.168"},
+            {"Tracking Error", "0.099"},
+            {"Treynor Ratio", "-5.187"},
+            {"Total Fees", "$65.00"},
+            {"Fitness Score", "0"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "1.51"},
+            {"Return Over Maximum Drawdown", "1.819"},
+            {"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", "852801548"}
+        };
+    }
+}

Algorithm.CSharp/BacktestingBrokerageRegressionAlgorithm.cs

@@ -1,4 +1,4 @@
-/*
+/*
  * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
  * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
  *
@@ -303,21 +303,39 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "0.400%"},
             {"Expectancy", "-1"},
             {"Net Profit", "-0.323%"},
-            {"Sharpe Ratio", "-0.888"},
+            {"Sharpe Ratio", "-11.098"},
             {"Probabilistic Sharpe Ratio", "0%"},
             {"Loss Rate", "100%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "0.035"},
-            {"Beta", "0.183"},
-            {"Annual Standard Deviation", "0.004"},
+            {"Alpha", "-0.002"},
+            {"Beta", "0.099"},
+            {"Annual Standard Deviation", "0.002"},
             {"Annual Variance", "0"},
-            {"Information Ratio", "12.058"},
-            {"Tracking Error", "0.017"},
-            {"Treynor Ratio", "-0.018"},
+            {"Information Ratio", "9.899"},
+            {"Tracking Error", "0.019"},
+            {"Treynor Ratio", "-0.23"},
             {"Total Fees", "$2.00"},
             {"Fitness Score", "0.213"},
-            {"OrderListHash", "904167951"}
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "79228162514264337593543950335"},
+            {"Return Over Maximum Drawdown", "-73.456"},
+            {"Portfolio Turnover", "0.426"},
+            {"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", "-1990039314"}
         };
     }
 }

Algorithm.CSharp/BasicSetAccountCurrencyAlgorithm.cs

@@ -107,7 +107,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "498372354"}
+            {"OrderListHash", "-1575550889"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateCryptoAlgorithm.cs

@@ -222,12 +222,12 @@ namespace QuantConnect.Algorithm.CSharp
             {"Information Ratio", "0"},
             {"Tracking Error", "0"},
             {"Treynor Ratio", "0"},
-            {"Total Fees", "$85.33"},
+            {"Total Fees", "$85.34"},
             {"Fitness Score", "0.5"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
             {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "-43.937"},
+            {"Return Over Maximum Drawdown", "-43.943"},
             {"Portfolio Turnover", "1.028"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
@@ -242,7 +242,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "415415696"}
+            {"OrderListHash", "956597072"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateOptionsFilterUniverseAlgorithm.cs

@@ -1,4 +1,4 @@
-/*
+/*
  * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
  * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
  *
@@ -102,7 +102,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
-            {"Total Trades", "1"},
+            {"Total Trades", "2"},
             {"Average Win", "0%"},
             {"Average Loss", "0%"},
             {"Compounding Annual Return", "0%"},
@@ -141,7 +141,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "687310345"}
+            {"OrderListHash", "-91832511"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateOptionsFrameworkAlgorithm.cs

@@ -160,7 +160,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Information Ratio", "0"},
             {"Tracking Error", "0"},
             {"Treynor Ratio", "0"},
-            {"Total Fees", "$4.00"},
+            {"Total Fees", "$3.00"},
             {"Fitness Score", "0"},
             {"Kelly Criterion Estimate", "0.327"},
             {"Kelly Criterion Probability Value", "1"},
@@ -180,7 +180,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "50.0482%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "352959406"}
+            {"OrderListHash", "-695205588"}
         };
     }
 }

Algorithm.CSharp/CBOECustomDataConsolidationRegressionAlgorithm.cs

@@ -0,0 +1,180 @@
+/*
+ * 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.IO;
+using QuantConnect.Data;
+using QuantConnect.Data.Custom.CBOE;
+using QuantConnect.Indicators;
+using QuantConnect.Interfaces;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Tests the consolidation of custom data with random data
+    /// </summary>
+    public class CBOECustomDataConsolidationRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Symbol _vix;
+        private BollingerBands _bb;
+        private bool _invested;
+
+        /// <summary>
+        /// Initializes the algorithm with fake VIX data
+        /// </summary>
+        public override void Initialize()
+        {
+            SetStartDate(2013, 10, 7);
+            SetEndDate(2013, 10, 11);
+            SetCash(100000);
+
+            _vix = AddData<IncrementallyGeneratedCustomData>("VIX", Resolution.Daily).Symbol;
+            _bb = BB(_vix, 30, 2, MovingAverageType.Simple, 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)
+        {
+            if (_bb.Current.Value == 0)
+            {
+                throw new Exception("Bollinger Band value is zero when we expect non-zero value.");
+            }
+
+            if (!_invested && _bb.Current.Value > 0.05m)
+            {
+                MarketOrder(_vix, 1);
+                _invested = true;
+            }
+        }
+
+        /// <summary>
+        /// Incrementally updating data
+        /// </summary>
+        private class IncrementallyGeneratedCustomData : CBOE
+        {
+            private const decimal _start = 10.01m;
+            private static decimal _step;
+
+            /// <summary>
+            /// Gets the source of the subscription. In this case, we set it to existing
+            /// equity data so that we can pass fake data from Reader
+            /// </summary>
+            /// <param name="config">Subscription configuration</param>
+            /// <param name="date">Date we're making this request</param>
+            /// <param name="isLiveMode">Is live mode</param>
+            /// <returns>Source of subscription</returns>
+            public override SubscriptionDataSource GetSource(SubscriptionDataConfig config, DateTime date, bool isLiveMode)
+            {
+                return new SubscriptionDataSource(Path.Combine(Globals.DataFolder, "equity", "usa", "minute", "spy", $"{date:yyyyMMdd}_trade.zip#{date:yyyyMMdd}_spy_minute_trade.csv"), SubscriptionTransportMedium.LocalFile, FileFormat.Csv);
+            }
+
+            /// <summary>
+            /// Reads the data, which in this case is fake incremental data
+            /// </summary>
+            /// <param name="config">Subscription configuration</param>
+            /// <param name="line">Line of data</param>
+            /// <param name="date">Date of the request</param>
+            /// <param name="isLiveMode">Is live mode</param>
+            /// <returns>Incremental BaseData instance</returns>
+            public override BaseData Reader(SubscriptionDataConfig config, string line, DateTime date, bool isLiveMode)
+            {
+                var vix = new CBOE();
+                _step += 0.10m;
+                var open = _start + _step;
+                var close = _start + _step + 0.02m;
+                var high = close;
+                var low = open;
+
+                return new IncrementallyGeneratedCustomData
+                {
+                    Open = open,
+                    High = high,
+                    Low = low,
+                    Close = close,
+                    Time = date,
+                    Symbol = new Symbol(
+                        SecurityIdentifier.GenerateBase(typeof(IncrementallyGeneratedCustomData), "VIX", Market.USA, false),
+                        "VIX"),
+                    Period = vix.Period,
+                    DataType = vix.DataType
+                };
+            }
+        }
+
+        /// <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>
+        /// <remarks>
+        /// Unable to be tested in Python, due to pythonnet not supporting overriding of methods from Python
+        /// </remarks>
+        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.029%"},
+            {"Drawdown", "0%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "0.000%"},
+            {"Sharpe Ratio", "28.4"},
+            {"Probabilistic Sharpe Ratio", "88.597%"},
+            {"Loss Rate", "0%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "0"},
+            {"Beta", "0"},
+            {"Annual Standard Deviation", "0"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "-7.067"},
+            {"Tracking Error", "0.193"},
+            {"Treynor Ratio", "7.887"},
+            {"Total Fees", "$0.00"},
+            {"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", "349101050"}
+        };
+    }
+}

Algorithm.CSharp/CancelOpenOrdersRegressionAlgorithm.cs

@@ -151,8 +151,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
             {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "-30.28"},
-            {"Portfolio Turnover", "1.029"},
+            {"Return Over Maximum Drawdown", "-30.158"},
+            {"Portfolio Turnover", "1.033"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
             {"Total Insights Analysis Completed", "0"},
@@ -166,7 +166,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "737971736"}
+            {"OrderListHash", "1349023435"}
         };
     }
 }

Algorithm.CSharp/ConvertToFrameworkAlgorithm.cs

@@ -144,7 +144,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Annual Variance", "0.027"},
             {"Information Ratio", "-0.391"},
             {"Tracking Error", "0.239"},
-            {"Treynor Ratio", "-1.416"},
+            {"Treynor Ratio", "-1.435"},
             {"Total Fees", "$755.29"},
             {"Fitness Score", "0.024"},
             {"Kelly Criterion Estimate", "-0.84"},

Algorithm.CSharp/CustomBenchmarkAlgorithm.cs

@@ -38,6 +38,10 @@ namespace QuantConnect.Algorithm.CSharp
             // Find more symbols here: http://quantconnect.com/data
             AddSecurity(SecurityType.Equity, "SPY", Resolution.Second);
 
+            // Disabling the benchmark / setting to a fixed value
+            // SetBenchmark(time => 0);
+
+            // Set the benchmark to AAPL US Equity
             SetBenchmark("AAPL");
         }
 

Algorithm.CSharp/CustomDataPropertiesRegressionAlgorithm.cs

@@ -0,0 +1,260 @@
+/*
+ * 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.Globalization;
+using Newtonsoft.Json;
+using QuantConnect.Data;
+using QuantConnect.Interfaces;
+using QuantConnect.Securities;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Regression test to demonstrate setting custom Symbol Properties and Market Hours for a custom data import
+    /// </summary>
+    /// <meta name="tag" content="using data" />
+    /// <meta name="tag" content="custom data" />
+    /// <meta name="tag" content="crypto" />
+    /// <meta name="tag" content="regression test" />
+    public class CustomDataPropertiesRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private string _ticker = "BTC";
+        private Security _bitcoin;
+
+        /// <summary>
+        /// Initialize 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);
+            SetEndDate(2015, 12, 01);
+
+            //Set the cash for the strategy:
+            SetCash(100000);
+
+            // Define our custom data properties and exchange hours
+            var properties = new SymbolProperties("Bitcoin", "USD", 1, 0.01m, 0.01m, _ticker);
+            var exchangeHours = SecurityExchangeHours.AlwaysOpen(TimeZones.NewYork);
+
+            // Add the custom data to our algorithm with our custom properties and exchange hours
+            _bitcoin = AddData<Bitcoin>(_ticker, properties, exchangeHours);
+
+            //Verify our symbol properties were changed and loaded into this security
+            if (_bitcoin.SymbolProperties != properties)
+            {
+                throw new Exception("Failed to set and retrieve custom SymbolProperties for BTC");
+            }
+
+            //Verify our exchange hours were changed and loaded into this security
+            if (_bitcoin.Exchange.Hours != exchangeHours)
+            {
+                throw new Exception("Failed to set and retrieve custom ExchangeHours for BTC");
+            }
+
+            // For regression purposes on AddData overloads, this call is simply to ensure Lean can accept this
+            // with default params and is not routed to a breaking function.
+            AddData<Bitcoin>("BTCUSD");
+        }
+
+        /// <summary>
+        /// Event Handler for Bitcoin Data Events: These Bitcoin objects are created from our
+        /// "Bitcoin" type below and fired into this event handler.
+        /// </summary>
+        /// <param name="data">One(1) Bitcoin Object, streamed into our algorithm synchronized in time with our other data streams</param>
+        public void OnData(Bitcoin data)
+        {
+            //If we don't have any bitcoin "SHARES" -- invest"
+            if (!Portfolio.Invested)
+            {
+                //Bitcoin used as a tradable asset, like stocks, futures etc.
+                if (data.Close != 0)
+                {
+                    //Access custom data symbols using <ticker>.<custom-type>
+                    Order("BTC.Bitcoin", Portfolio.MarginRemaining / Math.Abs(data.Close + 1));
+                }
+            }
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            // Reset our Symbol property value, for testing purposes.
+            SymbolPropertiesDatabase.SetEntry(Market.USA, MarketHoursDatabase.GetDatabaseSymbolKey(_bitcoin.Symbol), SecurityType.Base,
+                SymbolProperties.GetDefault("USD"));
+        }
+
+        /// <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", "155.262%"},
+            {"Drawdown", "84.800%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "5123.242%"},
+            {"Sharpe Ratio", "2.067"},
+            {"Probabilistic Sharpe Ratio", "68.833%"},
+            {"Loss Rate", "0%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "1.732"},
+            {"Beta", "0.037"},
+            {"Annual Standard Deviation", "0.841"},
+            {"Annual Variance", "0.707"},
+            {"Information Ratio", "1.902"},
+            {"Tracking Error", "0.848"},
+            {"Treynor Ratio", "46.992"},
+            {"Total Fees", "$0.00"},
+            {"Fitness Score", "0"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "2.238"},
+            {"Return Over Maximum Drawdown", "1.832"},
+            {"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", "508036553"}
+        };
+
+        /// <summary>
+        /// Custom Data Type: Bitcoin data from Quandl - http://www.quandl.com/help/api-for-bitcoin-data
+        /// </summary>
+        public class Bitcoin : BaseData
+        {
+            [JsonProperty("timestamp")]
+            public int Timestamp = 0;
+            [JsonProperty("open")]
+            public decimal Open = 0;
+            [JsonProperty("high")]
+            public decimal High = 0;
+            [JsonProperty("low")]
+            public decimal Low = 0;
+            [JsonProperty("last")]
+            public decimal Close = 0;
+            [JsonProperty("bid")]
+            public decimal Bid = 0;
+            [JsonProperty("ask")]
+            public decimal Ask = 0;
+            [JsonProperty("vwap")]
+            public decimal WeightedPrice = 0;
+            [JsonProperty("volume")]
+            public decimal VolumeBTC = 0;
+            public decimal VolumeUSD = 0;
+
+            /// <summary>
+            /// 1. DEFAULT CONSTRUCTOR: Custom data types need a default constructor.
+            /// We search for a default constructor so please provide one here. It won't be used for data, just to generate the "Factory".
+            /// </summary>
+            public Bitcoin()
+            {
+                Symbol = "BTC";
+            }
+
+            /// <summary>
+            /// 2. RETURN THE STRING URL SOURCE LOCATION FOR YOUR DATA:
+            /// This is a powerful and dynamic select source file method. If you have a large dataset, 10+mb we recommend you break it into smaller files. E.g. One zip per year.
+            /// We can accept raw text or ZIP files. We read the file extension to determine if it is a zip file.
+            /// </summary>
+            /// <param name="config">Configuration object</param>
+            /// <param name="date">Date of this source file</param>
+            /// <param name="isLiveMode">true if we're in live mode, false for backtesting mode</param>
+            /// <returns>String URL of source file.</returns>
+            public override SubscriptionDataSource GetSource(SubscriptionDataConfig config, DateTime date, bool isLiveMode)
+            {
+                if (isLiveMode)
+                {
+                    return new SubscriptionDataSource("https://www.bitstamp.net/api/ticker/", SubscriptionTransportMedium.Rest);
+                }
+
+                //return "http://my-ftp-server.com/futures-data-" + date.ToString("Ymd") + ".zip";
+                // OR simply return a fixed small data file. Large files will slow down your backtest
+                return new SubscriptionDataSource("https://www.quantconnect.com/api/v2/proxy/quandl/api/v3/datasets/BCHARTS/BITSTAMPUSD.csv?order=asc&api_key=WyAazVXnq7ATy_fefTqm", SubscriptionTransportMedium.RemoteFile);
+            }
+
+            /// <summary>
+            /// 3. READER METHOD: Read 1 line from data source and convert it into Object.
+            /// Each line of the CSV File is presented in here. The backend downloads your file, loads it into memory and then line by line
+            /// feeds it into your algorithm
+            /// </summary>
+            /// <param name="line">string line from the data source file submitted above</param>
+            /// <param name="config">Subscription data, symbol name, data type</param>
+            /// <param name="date">Current date we're requesting. This allows you to break up the data source into daily files.</param>
+            /// <param name="isLiveMode">true if we're in live mode, false for backtesting mode</param>
+            /// <returns>New Bitcoin Object which extends BaseData.</returns>
+            public override BaseData Reader(SubscriptionDataConfig config, string line, DateTime date, bool isLiveMode)
+            {
+                var coin = new Bitcoin();
+                if (isLiveMode)
+                {
+                    //Example Line Format:
+                    //{"high": "441.00", "last": "421.86", "timestamp": "1411606877", "bid": "421.96", "vwap": "428.58", "volume": "14120.40683975", "low": "418.83", "ask": "421.99"}
+                    try
+                    {
+                        coin = JsonConvert.DeserializeObject<Bitcoin>(line);
+                        coin.EndTime = DateTime.UtcNow.ConvertFromUtc(config.ExchangeTimeZone);
+                        coin.Value = coin.Close;
+                    }
+                    catch { /* Do nothing, possible error in json decoding */ }
+                    return coin;
+                }
+
+                //Example Line Format:
+                //Date      Open   High    Low     Close   Volume (BTC)    Volume (Currency)   Weighted Price
+                //2011-09-13 5.8    6.0     5.65    5.97    58.37138238,    346.0973893944      5.929230648356
+                try
+                {
+                    string[] data = line.Split(',');
+                    coin.Time = DateTime.Parse(data[0], CultureInfo.InvariantCulture);
+                    coin.Open = Convert.ToDecimal(data[1], CultureInfo.InvariantCulture);
+                    coin.High = Convert.ToDecimal(data[2], CultureInfo.InvariantCulture);
+                    coin.Low = Convert.ToDecimal(data[3], CultureInfo.InvariantCulture);
+                    coin.Close = Convert.ToDecimal(data[4], CultureInfo.InvariantCulture);
+                    coin.VolumeBTC = Convert.ToDecimal(data[5], CultureInfo.InvariantCulture);
+                    coin.VolumeUSD = Convert.ToDecimal(data[6], CultureInfo.InvariantCulture);
+                    coin.WeightedPrice = Convert.ToDecimal(data[7], CultureInfo.InvariantCulture);
+                    coin.Value = coin.Close;
+                }
+                catch { /* Do nothing, skip first title row */ }
+
+                return coin;
+            }
+        }
+    }
+}

Algorithm.CSharp/DelistedFutureLiquidateRegressionAlgorithm.cs

@@ -100,25 +100,25 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "1.300%"},
             {"Expectancy", "0"},
             {"Net Profit", "1.634%"},
-            {"Sharpe Ratio", "2.476"},
-            {"Probabilistic Sharpe Ratio", "92.194%"},
+            {"Sharpe Ratio", "2.495"},
+            {"Probabilistic Sharpe Ratio", "92.298%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "100%"},
             {"Profit-Loss Ratio", "0"},
             {"Alpha", "0.006"},
             {"Beta", "0.158"},
-            {"Annual Standard Deviation", "0.032"},
+            {"Annual Standard Deviation", "0.033"},
             {"Annual Variance", "0.001"},
-            {"Information Ratio", "-4.89"},
+            {"Information Ratio", "-4.942"},
             {"Tracking Error", "0.08"},
-            {"Treynor Ratio", "0.509"},
+            {"Treynor Ratio", "0.517"},
             {"Total Fees", "$3.70"},
             {"Fitness Score", "0.019"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
             {"Sortino Ratio", "1.362"},
             {"Return Over Maximum Drawdown", "9.699"},
-            {"Portfolio Turnover", "0.022"},
+            {"Portfolio Turnover", "0.023"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
             {"Total Insights Analysis Completed", "0"},
@@ -132,7 +132,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "-1252326142"}
+            {"OrderListHash", "528208939"}
         };
     }
 }

Algorithm.CSharp/DelistingEventsAlgorithm.cs

@@ -45,7 +45,7 @@ namespace QuantConnect.Algorithm.CSharp
             SetEndDate(2007, 05, 25);    //Set End Date
             SetCash(100000);             //Set Strategy Cash
             // Find more symbols here: http://quantconnect.com/data
-            AddSecurity(SecurityType.Equity, "AAA", Resolution.Daily);
+            AddSecurity(SecurityType.Equity, "AAA.1", Resolution.Daily);
             AddSecurity(SecurityType.Equity, "SPY", Resolution.Daily);
         }
 
@@ -58,7 +58,7 @@ namespace QuantConnect.Algorithm.CSharp
             _dataCount += data.Bars.Count;
             if (Transactions.OrdersCount == 0)
             {
-                SetHoldings("AAA", 1);
+                SetHoldings("AAA.1", 1);
                 Debug("Purchased Stock");
             }
 
@@ -71,7 +71,7 @@ namespace QuantConnect.Algorithm.CSharp
 
             // the slice can also contain delisting data: data.Delistings in a dictionary string->Delisting
 
-            var aaa = Securities["AAA"];
+            var aaa = Securities["AAA.1"];
             if (aaa.IsDelisted && aaa.IsTradable)
             {
                 throw new Exception("Delisted security must NOT be tradable");
@@ -179,7 +179,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "-2022527947"}
+            {"OrderListHash", "-335704027"}
         };
     }
 }

Algorithm.CSharp/DelistingFutureOptionRegressionAlgorithm.cs

@@ -0,0 +1,148 @@
+/*
+ * 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.Interfaces;
+using QuantConnect.Securities;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Regression algorithm reproducing issue #5160 where delisting order would be cancelled because it was placed at the market close on the delisting day
+    /// </summary>
+    public class DelistingFutureOptionRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private bool _traded;
+        private int _lastMonth;
+
+        public override void Initialize()
+        {
+            SetStartDate(2012, 1, 1);
+            SetEndDate(2013, 1, 1);
+            SetCash(10000000);
+
+            var dc = AddFuture(Futures.Dairy.ClassIIIMilk, Resolution.Minute, Market.CME);
+            dc.SetFilter(1, 120);
+
+            AddFutureOption(dc.Symbol, universe => universe.Strikes(-2, 2));
+            _lastMonth = -1;
+        }
+
+        public override void OnData(Slice data)
+        {
+            if (Time.Month != _lastMonth)
+            {
+                _lastMonth = Time.Month;
+                var investedSymbols = Securities.Values
+                    .Where(security => security.Invested)
+                    .Select(security => security.Symbol)
+                    .ToList();
+
+                var delistedSecurity = investedSymbols.Where(symbol => symbol.ID.Date.AddDays(1) < Time).ToList();
+                if (delistedSecurity.Count > 0)
+                {
+                    throw new Exception($"[{UtcTime}] We hold a delisted securities: {string.Join(",", delistedSecurity)}");
+                }
+                Log($"Holdings({Time}): {string.Join(",", investedSymbols)}");
+            }
+
+            if (Portfolio.Invested)
+            {
+                return;
+            }
+
+            foreach (var chain in data.OptionChains.Values)
+            {
+                foreach (var contractsValue in chain.Contracts.Values)
+                {
+                    MarketOrder(contractsValue.Symbol, 1);
+                    _traded = true;
+                }
+            }
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            if (!_traded)
+            {
+                throw new Exception("We expected some FOP trading to happen");
+            }
+            if (Portfolio.Invested)
+            {
+                throw new Exception("We shouldn't be invested anymore");
+            }
+        }
+
+        /// <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", "16"},
+            {"Average Win", "0.01%"},
+            {"Average Loss", "-0.02%"},
+            {"Compounding Annual Return", "-0.111%"},
+            {"Drawdown", "0.100%"},
+            {"Expectancy", "-0.679"},
+            {"Net Profit", "-0.112%"},
+            {"Sharpe Ratio", "-1.052"},
+            {"Probabilistic Sharpe Ratio", "0.000%"},
+            {"Loss Rate", "80%"},
+            {"Win Rate", "20%"},
+            {"Profit-Loss Ratio", "0.61"},
+            {"Alpha", "-0.001"},
+            {"Beta", "-0.001"},
+            {"Annual Standard Deviation", "0.001"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "-1.187"},
+            {"Tracking Error", "0.115"},
+            {"Treynor Ratio", "1.545"},
+            {"Total Fees", "$37.00"},
+            {"Fitness Score", "0"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "-0.128"},
+            {"Return Over Maximum Drawdown", "-0.995"},
+            {"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", "657651179"}
+        };
+    }
+}

Algorithm.CSharp/DropboxBaseDataUniverseSelectionAlgorithm.cs

@@ -187,12 +187,12 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "6441"},
             {"Average Win", "0.07%"},
             {"Average Loss", "-0.07%"},
-            {"Compounding Annual Return", "13.284%"},
+            {"Compounding Annual Return", "13.331%"},
             {"Drawdown", "10.700%"},
             {"Expectancy", "0.061"},
-            {"Net Profit", "13.284%"},
-            {"Sharpe Ratio", "0.96"},
-            {"Probabilistic Sharpe Ratio", "46.111%"},
+            {"Net Profit", "13.331%"},
+            {"Sharpe Ratio", "0.963"},
+            {"Probabilistic Sharpe Ratio", "46.232%"},
             {"Loss Rate", "46%"},
             {"Win Rate", "54%"},
             {"Profit-Loss Ratio", "0.97"},
@@ -200,15 +200,15 @@ namespace QuantConnect.Algorithm.CSharp
             {"Beta", "-0.066"},
             {"Annual Standard Deviation", "0.121"},
             {"Annual Variance", "0.015"},
-            {"Information Ratio", "0.004"},
+            {"Information Ratio", "0.006"},
             {"Tracking Error", "0.171"},
-            {"Treynor Ratio", "-1.754"},
-            {"Total Fees", "$8669.33"},
+            {"Treynor Ratio", "-1.761"},
+            {"Total Fees", "$8669.41"},
             {"Fitness Score", "0.675"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "1.124"},
-            {"Return Over Maximum Drawdown", "1.242"},
+            {"Sortino Ratio", "1.127"},
+            {"Return Over Maximum Drawdown", "1.246"},
             {"Portfolio Turnover", "1.64"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
@@ -223,7 +223,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "-1120327913"}
+            {"OrderListHash", "-75671425"}
         };
     }
 }

Algorithm.CSharp/DropboxUniverseSelectionAlgorithm.cs

@@ -160,12 +160,12 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "5059"},
             {"Average Win", "0.08%"},
             {"Average Loss", "-0.08%"},
-            {"Compounding Annual Return", "14.901%"},
+            {"Compounding Annual Return", "14.950%"},
             {"Drawdown", "10.600%"},
             {"Expectancy", "0.075"},
-            {"Net Profit", "14.901%"},
-            {"Sharpe Ratio", "1.068"},
-            {"Probabilistic Sharpe Ratio", "50.201%"},
+            {"Net Profit", "14.950%"},
+            {"Sharpe Ratio", "1.072"},
+            {"Probabilistic Sharpe Ratio", "50.327%"},
             {"Loss Rate", "45%"},
             {"Win Rate", "55%"},
             {"Profit-Loss Ratio", "0.97"},
@@ -173,15 +173,15 @@ namespace QuantConnect.Algorithm.CSharp
             {"Beta", "-0.066"},
             {"Annual Standard Deviation", "0.121"},
             {"Annual Variance", "0.015"},
-            {"Information Ratio", "0.08"},
+            {"Information Ratio", "0.083"},
             {"Tracking Error", "0.171"},
-            {"Treynor Ratio", "-1.963"},
-            {"Total Fees", "$6806.57"},
+            {"Treynor Ratio", "-1.971"},
+            {"Total Fees", "$6806.67"},
             {"Fitness Score", "0.694"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "1.261"},
-            {"Return Over Maximum Drawdown", "1.404"},
+            {"Sortino Ratio", "1.265"},
+            {"Return Over Maximum Drawdown", "1.409"},
             {"Portfolio Turnover", "1.296"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
@@ -196,7 +196,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "974523768"}
+            {"OrderListHash", "1142077166"}
         };
     }
 }

Algorithm.CSharp/EmitInsightCryptoCashAccountType.cs

@@ -90,13 +90,13 @@ namespace QuantConnect.Algorithm.CSharp
             {"Information Ratio", "0"},
             {"Tracking Error", "0"},
             {"Treynor Ratio", "0"},
-            {"Total Fees", "$14.91"},
+            {"Total Fees", "$14.92"},
             {"Fitness Score", "0.258"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
             {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "-27.251"},
-            {"Portfolio Turnover", "0.515"},
+            {"Return Over Maximum Drawdown", "-27.228"},
+            {"Portfolio Turnover", "0.516"},
             {"Total Insights Generated", "1"},
             {"Total Insights Closed", "1"},
             {"Total Insights Analysis Completed", "1"},
@@ -110,7 +110,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "221046152"}
+            {"OrderListHash", "1296183675"}
         };
     }
 }

Algorithm.CSharp/EquityTickQuoteAdjustedModeRegressionAlgorithm.cs

@@ -85,11 +85,11 @@ namespace QuantConnect.Algorithm.CSharp
         {
             {"Total Trades", "2"},
             {"Average Win", "0%"},
-            {"Average Loss", "-0.01%"},
-            {"Compounding Annual Return", "-0.500%"},
-            {"Drawdown", "0.000%"},
+            {"Average Loss", "-0.12%"},
+            {"Compounding Annual Return", "-9.062%"},
+            {"Drawdown", "0.100%"},
             {"Expectancy", "-1"},
-            {"Net Profit", "-0.006%"},
+            {"Net Profit", "-0.121%"},
             {"Sharpe Ratio", "0"},
             {"Probabilistic Sharpe Ratio", "0%"},
             {"Loss Rate", "100%"},
@@ -103,12 +103,12 @@ namespace QuantConnect.Algorithm.CSharp
             {"Tracking Error", "0.22"},
             {"Treynor Ratio", "0"},
             {"Total Fees", "$6.41"},
-            {"Fitness Score", "0.248"},
+            {"Fitness Score", "0.249"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
             {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "-82.815"},
-            {"Portfolio Turnover", "0.497"},
+            {"Return Over Maximum Drawdown", "-79.031"},
+            {"Portfolio Turnover", "0.498"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
             {"Total Insights Analysis Completed", "0"},
@@ -122,7 +122,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "1213851303"}
+            {"OrderListHash", "-1760998125"}
         };
     }
 }

Algorithm.CSharp/FeeModelNotUsingAccountCurrency.cs

@@ -179,7 +179,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Kelly Criterion Probability Value", "0"},
             {"Sortino Ratio", "79228162514264337593543950335"},
             {"Return Over Maximum Drawdown", "-15.574"},
-            {"Portfolio Turnover", "2.056"},
+            {"Portfolio Turnover", "2.057"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
             {"Total Insights Analysis Completed", "0"},
@@ -193,7 +193,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "-1311542155"}
+            {"OrderListHash", "-1116140375"}
         };
     }
 }

Algorithm.CSharp/FillForwardEnumeratorOutOfOrderBarRegressionAlgorithm.cs

@@ -0,0 +1,123 @@
+/*
+ * 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;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Regression test algorithm simply fetch and compare data of minute resolution around daylight saving period
+    /// reproduces issue reported in GB issue GH issue https://github.com/QuantConnect/Lean/issues/4925
+    /// related issues https://github.com/QuantConnect/Lean/issues/3707; https://github.com/QuantConnect/Lean/issues/4630
+    /// </summary>
+    public class FillForwardEnumeratorOutOfOrderBarRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private decimal _exptectedClose = 84.09m;
+        private DateTime _exptectedTime = new DateTime(2008, 3, 10, 9, 30, 0);
+        private Symbol _shy;
+
+        /// <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(2008, 3, 7);
+            SetEndDate(2008, 3, 10);
+            _shy = AddEquity("SHY", Resolution.Minute).Symbol;
+            // just to make debugging easier, less subscriptions
+            SetBenchmark(time => 1);
+        }
+
+        public override void OnData(Slice slice)
+        {
+            var trackingBar = slice.Bars.Values.FirstOrDefault(s => s.Time.Equals(_exptectedTime));
+
+            if (trackingBar != null)
+            {
+                if (!Portfolio.Invested)
+                {
+                    SetHoldings(_shy, 1);
+                }
+
+                if (trackingBar.Close != _exptectedClose)
+                {
+                    throw new Exception(
+                        $"Bar at {_exptectedTime.ToStringInvariant()} closed at price {trackingBar.Close.ToStringInvariant()}; expected {_exptectedClose.ToStringInvariant()}");
+                }
+            }
+        }
+
+        /// <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", "$5.93"},
+            {"Fitness Score", "0.499"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "79228162514264337593543950335"},
+            {"Return Over Maximum Drawdown", "-105.726"},
+            {"Portfolio Turnover", "0.998"},
+            {"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", "-850144190"}
+        };
+    }
+}

Algorithm.CSharp/FillForwardUntilExpiryRegressionAlgorithm.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 QuantConnect.Data;
+using QuantConnect.Data.UniverseSelection;
+using QuantConnect.Interfaces;
+using QuantConnect.Securities.Option;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using QuantConnect.Data.Market;
+using QuantConnect.Securities;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Regression algorithm checks FillForwardEnumerator should FF the data until it reaches the delisting date
+    /// replicates GH issue https://github.com/QuantConnect/Lean/issues/4872
+    /// </summary>
+    public class FillForwardUntilExpiryRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private DateTime _realEndDate = new DateTime(2014, 06, 07);
+        private SecurityExchange _exchange;
+        private Dictionary<Symbol, HashSet<DateTime>> _options;
+
+        private string[] _contracts =
+        {
+            "TWX   140621P00067500",
+            "TWX   140621C00067500",
+            "TWX   140621C00070000",
+            "TWX   140621P00070000"
+        };
+
+        public override void Initialize()
+        {
+            SetStartDate(2014, 06, 05);
+            SetEndDate(2014, 06, 30);
+
+            _options = new Dictionary<Symbol, HashSet<DateTime>>();
+            var _twxOption = AddOption("TWX", Resolution.Minute);
+            _exchange = _twxOption.Exchange;
+            _twxOption.SetFilter((x) => x
+                .Contracts(c => c.Where(s => _contracts.Contains(s.Value))));
+            SetBenchmark(t => 1);
+        }
+
+        public override void OnData(Slice data)
+        {
+            foreach (var value in data.OptionChains.Values)
+            {
+                foreach (var contact in value.Contracts)
+                {
+                    BaseData bar = null;
+                    QuoteBar quoteBar;
+                    if (bar == null && value.QuoteBars.TryGetValue(contact.Key, out quoteBar))
+                    {
+                        bar = quoteBar;
+                    }
+                    TradeBar tradeBar;
+                    if (bar == null && value.TradeBars.TryGetValue(contact.Key, out tradeBar))
+                    {
+                        bar = tradeBar;
+                    }
+                    if (bar.IsFillForward)
+                    {
+                        _options[contact.Key].Add(value.Time.Date);
+                    }
+                }
+            }
+        }
+
+        public override void OnSecuritiesChanged(SecurityChanges changes)
+        {
+            foreach (var security in changes.AddedSecurities.OfType<Option>())
+            {
+                _options.Add(security.Symbol, new HashSet<DateTime>());
+            }
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            if (_options.Count != _contracts.Length)
+            {
+                throw new Exception($"Options weren't setup properly. Expected: {_contracts.Length}");
+            }
+
+            foreach (var option in _options)
+            {
+                for (DateTime date = _realEndDate; date < option.Key.ID.Date; date = date.AddDays(1))
+                {
+                    if (_exchange.Hours.IsDateOpen(date) &&
+                        !option.Value.Contains(date))
+                    {
+                        throw new Exception("Delisted security should be FF until expiry date");
+                    }
+                }
+            }
+        }
+
+        /// <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", "0"},
+            {"Tracking Error", "0"},
+            {"Treynor Ratio", "0"},
+            {"Total Fees", "$0.00"},
+            {"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", "371857150"}
+        };
+    }
+}

Algorithm.CSharp/ForexInternalFeedOnDataHigherResolutionRegressionAlgorithm.cs

@@ -30,6 +30,7 @@ namespace QuantConnect.Algorithm.CSharp
         private readonly Dictionary<Symbol, int> _dataPointsPerSymbol = new Dictionary<Symbol, int>();
         private bool _added;
         private Symbol _eurusd;
+        private DateTime lastDataTime = DateTime.MinValue;
 
         /// <summary>
         /// Initialise the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must initialized.
@@ -51,6 +52,13 @@ namespace QuantConnect.Algorithm.CSharp
         /// <param name="data">Slice object keyed by symbol containing the stock data</param>
         public override void OnData(Slice data)
         {
+            if (lastDataTime == data.Time)
+            {
+                throw new Exception("Duplicate time for current data and last data slice");
+            }
+
+            lastDataTime = data.Time;
+
             if (_added)
             {
                 var eurUsdSubscription = SubscriptionManager.SubscriptionDataConfigService
@@ -94,7 +102,7 @@ namespace QuantConnect.Algorithm.CSharp
             var expectedDataPointsPerSymbol = new Dictionary<string, int>
             {
                 { "EURGBP", 3 },
-                { "EURUSD", 29 }
+                { "EURUSD", 28 }
             };
 
             foreach (var kvp in _dataPointsPerSymbol)

Algorithm.CSharp/ForexInternalFeedOnDataSameResolutionRegressionAlgorithm.cs

@@ -30,6 +30,7 @@ namespace QuantConnect.Algorithm.CSharp
         private readonly Dictionary<Symbol, int> _dataPointsPerSymbol = new Dictionary<Symbol, int>();
         private bool _added;
         private Symbol _eurusd;
+        private DateTime lastDataTime = DateTime.MinValue;
 
         /// <summary>
         /// Initialise the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must initialized.
@@ -51,6 +52,13 @@ namespace QuantConnect.Algorithm.CSharp
         /// <param name="data">Slice object keyed by symbol containing the stock data</param>
         public override void OnData(Slice data)
         {
+            if (lastDataTime == data.Time)
+            {
+                throw new Exception("Duplicate time for current data and last data slice");
+            }
+
+            lastDataTime = data.Time;
+
             if (_added)
             {
                 var eurUsdSubscription = SubscriptionManager.SubscriptionDataConfigService
@@ -96,7 +104,7 @@ namespace QuantConnect.Algorithm.CSharp
                 // normal feed
                 { "EURGBP", 3 },
                 // internal feed on the first day, normal feed on the other two days
-                { "EURUSD", 3 },
+                { "EURUSD", 2 },
                 // internal feed only
                 { "GBPUSD", 0 }
             };

Algorithm.CSharp/FractionalQuantityRegressionAlgorithm.cs

@@ -101,7 +101,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "6"},
             {"Average Win", "6.02%"},
             {"Average Loss", "-2.40%"},
-            {"Compounding Annual Return", "915.481%"},
+            {"Compounding Annual Return", "915.480%"},
             {"Drawdown", "5.500%"},
             {"Expectancy", "1.338"},
             {"Net Profit", "11.400%"},
@@ -117,7 +117,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Information Ratio", "9.507"},
             {"Tracking Error", "0.507"},
             {"Treynor Ratio", "0"},
-            {"Total Fees", "$2651.00"},
+            {"Total Fees", "$2651.01"},
             {"Fitness Score", "0.467"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
@@ -137,7 +137,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "-1241317053"}
+            {"OrderListHash", "-89452746"}
         };
     }
 }

Algorithm.CSharp/FreePortfolioValueRegressionAlgorithm.cs

@@ -92,12 +92,12 @@ namespace QuantConnect.Algorithm.CSharp
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
             {"Alpha", "0.093"},
-            {"Beta", "-0.1"},
+            {"Beta", "-0.099"},
             {"Annual Standard Deviation", "0.18"},
             {"Annual Variance", "0.032"},
             {"Information Ratio", "-0.001"},
             {"Tracking Error", "0.267"},
-            {"Treynor Ratio", "-0.846"},
+            {"Treynor Ratio", "-0.847"},
             {"Total Fees", "$41.17"},
             {"Fitness Score", "0"},
             {"Kelly Criterion Estimate", "38.884"},

Algorithm.CSharp/FutureOptionBuySellCallIntradayRegressionAlgorithm.cs

@@ -0,0 +1,164 @@
+/*
+ * 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.Interfaces;
+using QuantConnect.Securities;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// This regression algorithm tests In The Money (ITM) future option calls across different strike prices.
+    /// We expect 6 orders from the algorithm, which are:
+    ///
+    ///   * (1) Initial entry, buy ES Call Option (ES19M20 expiring ITM)
+    ///   * (2) Initial entry, sell ES Call Option at different strike (ES20H20 expiring ITM)
+    ///   * [2] Option assignment, opens a position in the underlying (ES20H20, Qty: -1)
+    ///   * [2] Future contract liquidation, due to impending expiry
+    ///   * [1] Option exercise, receive 1 ES19M20 future contract
+    ///   * [1] Liquidate ES19M20 contract, due to expiry
+    ///
+    /// Additionally, we test delistings for future options and assert that our
+    /// portfolio holdings reflect the orders the algorithm has submitted.
+    /// </summary>
+    public class FutureOptionBuySellCallIntradayRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        public override void Initialize()
+        {
+            SetStartDate(2020, 1, 5);
+            SetEndDate(2020, 6, 30);
+
+            var es20h20 = AddFutureContract(
+                QuantConnect.Symbol.CreateFuture(
+                    Futures.Indices.SP500EMini,
+                    Market.CME,
+                    new DateTime(2020, 3, 20)),
+                Resolution.Minute).Symbol;
+
+            var es20m20 = AddFutureContract(
+                QuantConnect.Symbol.CreateFuture(
+                    Futures.Indices.SP500EMini,
+                    Market.CME,
+                    new DateTime(2020, 6, 19)),
+                Resolution.Minute).Symbol;
+
+            // Select a future option expiring ITM, and adds it to the algorithm.
+            var esOptions = OptionChainProvider.GetOptionContractList(es20m20, Time)
+                .Concat(OptionChainProvider.GetOptionContractList(es20h20, Time))
+                .Where(x => x.ID.StrikePrice == 3200m && x.ID.OptionRight == OptionRight.Call)
+                .Select(x => AddFutureOptionContract(x, Resolution.Minute).Symbol)
+                .ToList();
+
+            var expectedContracts = new[]
+            {
+                QuantConnect.Symbol.CreateOption(es20h20, Market.CME, OptionStyle.American, OptionRight.Call, 3200m,
+                    new DateTime(2020, 3, 20)),
+                QuantConnect.Symbol.CreateOption(es20m20, Market.CME, OptionStyle.American, OptionRight.Call, 3200m,
+                    new DateTime(2020, 6, 19))
+            };
+
+            foreach (var esOption in esOptions)
+            {
+                if (!expectedContracts.Contains(esOption))
+                {
+                    throw new Exception($"Contract {esOption} was not found in the chain");
+                }
+            }
+
+            Schedule.On(DateRules.Tomorrow, TimeRules.AfterMarketOpen(es20m20, 1), () =>
+            {
+                MarketOrder(esOptions[0], 1);
+                MarketOrder(esOptions[1], -1);
+            });
+            Schedule.On(DateRules.Tomorrow, TimeRules.Noon, () =>
+            {
+                Liquidate();
+            });
+        }
+
+        /// <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)}");
+            }
+        }
+
+        /// <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", "6"},
+            {"Average Win", "2.93%"},
+            {"Average Loss", "-4.15%"},
+            {"Compounding Annual Return", "-6.023%"},
+            {"Drawdown", "5.700%"},
+            {"Expectancy", "-0.148"},
+            {"Net Profit", "-2.802%"},
+            {"Sharpe Ratio", "-0.501"},
+            {"Probabilistic Sharpe Ratio", "10.679%"},
+            {"Loss Rate", "50%"},
+            {"Win Rate", "50%"},
+            {"Profit-Loss Ratio", "0.70"},
+            {"Alpha", "-0.045"},
+            {"Beta", "-0.001"},
+            {"Annual Standard Deviation", "0.089"},
+            {"Annual Variance", "0.008"},
+            {"Information Ratio", "0.966"},
+            {"Tracking Error", "0.195"},
+            {"Treynor Ratio", "55.977"},
+            {"Total Fees", "$14.80"},
+            {"Fitness Score", "0.018"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "-0.103"},
+            {"Return Over Maximum Drawdown", "-1.063"},
+            {"Portfolio Turnover", "0.045"},
+            {"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", "79413316"}
+        };
+    }
+}
+

Algorithm.CSharp/FutureOptionCallITMExpiryRegressionAlgorithm.cs

@@ -0,0 +1,248 @@
+/*
+ * 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.Orders;
+using QuantConnect.Securities;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// This regression algorithm tests In The Money (ITM) future option expiry for calls.
+    /// We expect 3 orders from the algorithm, which are:
+    ///
+    ///   * Initial entry, buy ES Call Option (expiring ITM)
+    ///   * Option exercise, receiving ES future contracts
+    ///   * Future contract liquidation, due to impending expiry
+    ///
+    /// Additionally, we test delistings for future options and assert that our
+    /// portfolio holdings reflect the orders the algorithm has submitted.
+    /// </summary>
+    public class FutureOptionCallITMExpiryRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Symbol _es19m20;
+        private Symbol _esOption;
+        private Symbol _expectedOptionContract;
+
+        public override void Initialize()
+        {
+            SetStartDate(2020, 1, 5);
+            SetEndDate(2020, 6, 30);
+
+            _es19m20 = AddFutureContract(
+                QuantConnect.Symbol.CreateFuture(
+                    Futures.Indices.SP500EMini,
+                    Market.CME,
+                    new DateTime(2020, 6, 19)),
+                Resolution.Minute).Symbol;
+
+            // Select a future option expiring ITM, and adds it to the algorithm.
+            _esOption = AddFutureOptionContract(OptionChainProvider.GetOptionContractList(_es19m20, Time)
+                .Where(x => x.ID.StrikePrice <= 3200m && x.ID.OptionRight == OptionRight.Call)
+                .OrderByDescending(x => x.ID.StrikePrice)
+                .Take(1)
+                .Single(), Resolution.Minute).Symbol;
+
+            _expectedOptionContract = QuantConnect.Symbol.CreateOption(_es19m20, Market.CME, OptionStyle.American, OptionRight.Call, 3200m, new DateTime(2020, 6, 19));
+            if (_esOption != _expectedOptionContract)
+            {
+                throw new Exception($"Contract {_expectedOptionContract} was not found in the chain");
+            }
+
+            Schedule.On(DateRules.Tomorrow, TimeRules.AfterMarketOpen(_es19m20, 1), () =>
+            {
+                MarketOrder(_esOption, 1);
+            });
+        }
+
+        public override void OnData(Slice data)
+        {
+            // Assert delistings, so that we can make sure that we receive the delisting warnings at
+            // the expected time. These assertions detect bug #4872
+            foreach (var delisting in data.Delistings.Values)
+            {
+                if (delisting.Type == DelistingType.Warning)
+                {
+                    if (delisting.Time != new DateTime(2020, 6, 19))
+                    {
+                        throw new Exception($"Delisting warning issued at unexpected date: {delisting.Time}");
+                    }
+                }
+                if (delisting.Type == DelistingType.Delisted)
+                {
+                    if (delisting.Time != new DateTime(2020, 6, 20))
+                    {
+                        throw new Exception($"Delisting happened at unexpected date: {delisting.Time}");
+                    }
+                }
+            }
+        }
+
+        public override void OnOrderEvent(OrderEvent orderEvent)
+        {
+            if (orderEvent.Status != OrderStatus.Filled)
+            {
+                // There's lots of noise with OnOrderEvent, but we're only interested in fills.
+                return;
+            }
+
+            if (!Securities.ContainsKey(orderEvent.Symbol))
+            {
+                throw new Exception($"Order event Symbol not found in Securities collection: {orderEvent.Symbol}");
+            }
+
+            var security = Securities[orderEvent.Symbol];
+            if (security.Symbol == _es19m20)
+            {
+                AssertFutureOptionOrderExercise(orderEvent, security, Securities[_expectedOptionContract]);
+            }
+            else if (security.Symbol == _expectedOptionContract)
+            {
+                AssertFutureOptionContractOrder(orderEvent, security);
+            }
+            else
+            {
+                throw new Exception($"Received order event for unknown Symbol: {orderEvent.Symbol}");
+            }
+
+            Log($"{Time:yyyy-MM-dd HH:mm:ss} -- {orderEvent.Symbol} :: Price: {Securities[orderEvent.Symbol].Holdings.Price} Qty: {Securities[orderEvent.Symbol].Holdings.Quantity} Direction: {orderEvent.Direction} Msg: {orderEvent.Message}");
+        }
+
+        private void AssertFutureOptionOrderExercise(OrderEvent orderEvent, Security future, Security optionContract)
+        {
+            var expectedLiquidationTimeUtc = new DateTime(2020, 6, 19, 20, 0, 0);
+
+            if (orderEvent.Direction == OrderDirection.Sell && future.Holdings.Quantity != 0)
+            {
+                // We expect the contract to have been liquidated immediately
+                throw new Exception($"Did not liquidate existing holdings for Symbol {future.Symbol}");
+            }
+            if (orderEvent.Direction == OrderDirection.Sell && orderEvent.UtcTime != expectedLiquidationTimeUtc)
+            {
+                throw new Exception($"Liquidated future contract, but not at the expected time. Expected: {expectedLiquidationTimeUtc:yyyy-MM-dd HH:mm:ss} - found {orderEvent.UtcTime:yyyy-MM-dd HH:mm:ss}");
+            }
+
+            // No way to detect option exercise orders or any other kind of special orders
+            // other than matching strings, for now.
+            if (orderEvent.Message.Contains("Option Exercise"))
+            {
+                if (orderEvent.FillPrice != 3200m)
+                {
+                    throw new Exception("Option did not exercise at expected strike price (3200)");
+                }
+                if (future.Holdings.Quantity != 1)
+                {
+                    // Here, we expect to have some holdings in the underlying, but not in the future option anymore.
+                    throw new Exception($"Exercised option contract, but we have no holdings for Future {future.Symbol}");
+                }
+
+                if (optionContract.Holdings.Quantity != 0)
+                {
+                    throw new Exception($"Exercised option contract, but we have holdings for Option contract {optionContract.Symbol}");
+                }
+            }
+        }
+
+        private void AssertFutureOptionContractOrder(OrderEvent orderEvent, Security option)
+        {
+            if (orderEvent.Direction == OrderDirection.Buy && option.Holdings.Quantity != 1)
+            {
+                throw new Exception($"No holdings were created for option contract {option.Symbol}");
+            }
+            if (orderEvent.Direction == OrderDirection.Sell && option.Holdings.Quantity != 0)
+            {
+                throw new Exception($"Holdings were found after a filled option exercise");
+            }
+            if (orderEvent.Message.Contains("Exercise") && option.Holdings.Quantity != 0)
+            {
+                throw new Exception($"Holdings were found after exercising option contract {option.Symbol}");
+            }
+        }
+
+        /// <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)}");
+            }
+        }
+
+        /// <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.22%"},
+            {"Average Loss", "-7.42%"},
+            {"Compounding Annual Return", "-13.222%"},
+            {"Drawdown", "6.300%"},
+            {"Expectancy", "-0.417"},
+            {"Net Profit", "-6.282%"},
+            {"Sharpe Ratio", "-1.345"},
+            {"Probabilistic Sharpe Ratio", "0.005%"},
+            {"Loss Rate", "50%"},
+            {"Win Rate", "50%"},
+            {"Profit-Loss Ratio", "0.17"},
+            {"Alpha", "-0.105"},
+            {"Beta", "-0.003"},
+            {"Annual Standard Deviation", "0.078"},
+            {"Annual Variance", "0.006"},
+            {"Information Ratio", "0.678"},
+            {"Tracking Error", "0.191"},
+            {"Treynor Ratio", "33.18"},
+            {"Total Fees", "$7.40"},
+            {"Fitness Score", "0.008"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "-0.217"},
+            {"Return Over Maximum Drawdown", "-2.105"},
+            {"Portfolio Turnover", "0.024"},
+            {"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", "-1947859887"}
+        };
+    }
+}
+

Algorithm.CSharp/FutureOptionCallITMGreeksExpiryRegressionAlgorithm.cs

@@ -0,0 +1,206 @@
+/*
+ * 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;
+using QuantConnect.Securities.Option;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// This regression algorithm tests In The Money (ITM) future option expiry for calls.
+    /// We test to make sure that FOPs have greeks enabled, same as equity options.
+    /// </summary>
+    public class FutureOptionCallITMGreeksExpiryRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private bool _invested;
+        private int _onDataCalls;
+        private Symbol _es19m20;
+        private Option _esOption;
+        private Symbol _expectedOptionContract;
+
+        public override void Initialize()
+        {
+            SetStartDate(2020, 1, 5);
+            SetEndDate(2020, 6, 30);
+
+            _es19m20 = AddFutureContract(
+                QuantConnect.Symbol.CreateFuture(
+                    Futures.Indices.SP500EMini,
+                    Market.CME,
+                    new DateTime(2020, 6, 19)),
+                Resolution.Minute).Symbol;
+
+            // Select a future option expiring ITM, and adds it to the algorithm.
+            _esOption = AddFutureOptionContract(OptionChainProvider.GetOptionContractList(_es19m20, new DateTime(2020, 1, 5))
+                .Where(x => x.ID.StrikePrice <= 3200m && x.ID.OptionRight == OptionRight.Call)
+                .OrderByDescending(x => x.ID.StrikePrice)
+                .Take(1)
+                .Single(), Resolution.Minute);
+
+            _esOption.PriceModel = OptionPriceModels.BjerksundStensland();
+
+            _expectedOptionContract = QuantConnect.Symbol.CreateOption(_es19m20, Market.CME, OptionStyle.American, OptionRight.Call, 3200m, new DateTime(2020, 6, 19));
+            if (_esOption.Symbol != _expectedOptionContract)
+            {
+                throw new Exception($"Contract {_expectedOptionContract} was not found in the chain");
+            }
+        }
+
+        public override void OnData(Slice data)
+        {
+            // Let the algo warmup, but without using SetWarmup. Otherwise, we get
+            // no contracts in the option chain
+            if (_invested || _onDataCalls++ < 40)
+            {
+                return;
+            }
+
+            if (data.OptionChains.Count == 0)
+            {
+                return;
+            }
+            if (data.OptionChains.Values.All(o => o.Contracts.Values.Any(c => !data.ContainsKey(c.Symbol))))
+            {
+                return;
+            }
+            if (data.OptionChains.Values.First().Contracts.Count == 0)
+            {
+                throw new Exception($"No contracts found in the option {data.OptionChains.Keys.First()}");
+            }
+
+            var deltas = data.OptionChains.Values.OrderByDescending(y => y.Contracts.Values.Sum(x => x.Volume)).First().Contracts.Values.Select(x => x.Greeks.Delta).ToList();
+            var gammas = data.OptionChains.Values.OrderByDescending(y => y.Contracts.Values.Sum(x => x.Volume)).First().Contracts.Values.Select(x => x.Greeks.Gamma).ToList();
+            var lambda = data.OptionChains.Values.OrderByDescending(y => y.Contracts.Values.Sum(x => x.Volume)).First().Contracts.Values.Select(x => x.Greeks.Lambda).ToList();
+            var rho = data.OptionChains.Values.OrderByDescending(y => y.Contracts.Values.Sum(x => x.Volume)).First().Contracts.Values.Select(x => x.Greeks.Rho).ToList();
+            var theta = data.OptionChains.Values.OrderByDescending(y => y.Contracts.Values.Sum(x => x.Volume)).First().Contracts.Values.Select(x => x.Greeks.Theta).ToList();
+            var vega = data.OptionChains.Values.OrderByDescending(y => y.Contracts.Values.Sum(x => x.Volume)).First().Contracts.Values.Select(x => x.Greeks.Vega).ToList();
+
+            // The commented out test cases all return zero.
+            // This is because of failure to evaluate the greeks in the option pricing model.
+            // For now, let's skip those.
+            if (deltas.Any(d => d == 0))
+            {
+                throw new AggregateException("Option contract Delta was equal to zero");
+            }
+            if (gammas.Any(g => g == 0))
+            {
+                throw new AggregateException("Option contract Gamma was equal to zero");
+            }
+            //if (lambda.Any(l => l == 0))
+            //{
+            //    throw new AggregateException("Option contract Lambda was equal to zero");
+            //}
+            if (rho.Any(r => r == 0))
+            {
+                throw new AggregateException("Option contract Rho was equal to zero");
+            }
+            //if (theta.Any(t => t == 0))
+            //{
+            //    throw new AggregateException("Option contract Theta was equal to zero");
+            //}
+            //if (vega.Any(v => v == 0))
+            //{
+            //    throw new AggregateException("Option contract Vega was equal to zero");
+            //}
+
+            if (!_invested)
+            {
+                SetHoldings(data.OptionChains.Values.First().Contracts.Values.First().Symbol, 1);
+                _invested = true;
+            }
+        }
+
+        /// <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 (!_invested)
+            {
+                throw new Exception($"Never checked greeks, maybe we have no option data?");
+            }
+        }
+
+        /// <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", "27.44%"},
+            {"Average Loss", "-62.81%"},
+            {"Compounding Annual Return", "-80.444%"},
+            {"Drawdown", "52.600%"},
+            {"Expectancy", "-0.282"},
+            {"Net Profit", "-52.604%"},
+            {"Sharpe Ratio", "-0.867"},
+            {"Probabilistic Sharpe Ratio", "0.021%"},
+            {"Loss Rate", "50%"},
+            {"Win Rate", "50%"},
+            {"Profit-Loss Ratio", "0.44"},
+            {"Alpha", "-0.611"},
+            {"Beta", "-0.033"},
+            {"Annual Standard Deviation", "0.695"},
+            {"Annual Variance", "0.484"},
+            {"Information Ratio", "-0.513"},
+            {"Tracking Error", "0.718"},
+            {"Treynor Ratio", "18.473"},
+            {"Total Fees", "$66.60"},
+            {"Fitness Score", "0.162"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "-0.136"},
+            {"Return Over Maximum Drawdown", "-1.529"},
+            {"Portfolio Turnover", "0.427"},
+            {"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", "1153646593"}
+        };
+    }
+}
+

Algorithm.CSharp/FutureOptionCallOTMExpiryRegressionAlgorithm.cs

@@ -0,0 +1,223 @@
+/*
+ * 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 Out of The Money (OTM) future option expiry for calls.
+    /// We expect 2 orders from the algorithm, which are:
+    ///
+    ///   * Initial entry, buy ES Call Option (expiring OTM)
+    ///     - contract expires worthless, not exercised, so never opened a position in the underlying
+    ///
+    ///   * Liquidation of worthless ES call option (expiring OTM)
+    ///
+    /// Additionally, we test delistings for future options and assert that our
+    /// portfolio holdings reflect the orders the algorithm has submitted.
+    /// </summary>
+    /// <remarks>
+    /// Total Trades in regression algorithm should be 1, but expiration is counted as a trade.
+    /// See related issue: https://github.com/QuantConnect/Lean/issues/4854
+    /// </remarks>
+    public class FutureOptionCallOTMExpiryRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Symbol _es19m20;
+        private Symbol _esOption;
+        private Symbol _expectedContract;
+
+        public override void Initialize()
+        {
+            SetStartDate(2020, 1, 5);
+            SetEndDate(2020, 6, 30);
+
+            _es19m20 = AddFutureContract(
+                QuantConnect.Symbol.CreateFuture(
+                    Futures.Indices.SP500EMini,
+                    Market.CME,
+                    new DateTime(2020, 6, 19)),
+                Resolution.Minute).Symbol;
+
+            // Select a future option call expiring OTM, and adds it to the algorithm.
+            _esOption = AddFutureOptionContract(OptionChainProvider.GetOptionContractList(_es19m20, Time)
+                .Where(x => x.ID.StrikePrice >= 3300m && x.ID.OptionRight == OptionRight.Call)
+                .OrderBy(x => x.ID.StrikePrice)
+                .Take(1)
+                .Single(), Resolution.Minute).Symbol;
+
+            _expectedContract = QuantConnect.Symbol.CreateOption(_es19m20, Market.CME, OptionStyle.American, OptionRight.Call, 3300m, new DateTime(2020, 6, 19));
+            if (_esOption != _expectedContract)
+            {
+                throw new Exception($"Contract {_expectedContract} was not found in the chain");
+            }
+
+            Schedule.On(DateRules.Tomorrow, TimeRules.AfterMarketOpen(_es19m20, 1), () =>
+            {
+                MarketOrder(_esOption, 1);
+            });
+        }
+
+        public override void OnData(Slice data)
+        {
+            // Assert delistings, so that we can make sure that we receive the delisting warnings at
+            // the expected time. These assertions detect bug #4872
+            foreach (var delisting in data.Delistings.Values)
+            {
+                if (delisting.Type == DelistingType.Warning)
+                {
+                    if (delisting.Time != new DateTime(2020, 6, 19))
+                    {
+                        throw new Exception($"Delisting warning issued at unexpected date: {delisting.Time}");
+                    }
+                }
+                if (delisting.Type == DelistingType.Delisted)
+                {
+                    if (delisting.Time != new DateTime(2020, 6, 20))
+                    {
+                        throw new Exception($"Delisting happened at unexpected date: {delisting.Time}");
+                    }
+                }
+            }
+        }
+
+        public override void OnOrderEvent(OrderEvent orderEvent)
+        {
+            if (orderEvent.Status != OrderStatus.Filled)
+            {
+                // There's lots of noise with OnOrderEvent, but we're only interested in fills.
+                return;
+            }
+
+            if (!Securities.ContainsKey(orderEvent.Symbol))
+            {
+                throw new Exception($"Order event Symbol not found in Securities collection: {orderEvent.Symbol}");
+            }
+
+            var security = Securities[orderEvent.Symbol];
+            if (security.Symbol == _es19m20)
+            {
+                throw new Exception("Invalid state: did not expect a position for the underlying to be opened, since this contract expires OTM");
+            }
+            if (security.Symbol == _expectedContract)
+            {
+                AssertFutureOptionContractOrder(orderEvent, security);
+            }
+            else
+            {
+                throw new Exception($"Received order event for unknown Symbol: {orderEvent.Symbol}");
+            }
+
+            Log($"{orderEvent}");
+        }
+
+        private void AssertFutureOptionContractOrder(OrderEvent orderEvent, Security option)
+        {
+            if (orderEvent.Direction == OrderDirection.Buy && option.Holdings.Quantity != 1)
+            {
+                throw new Exception($"No holdings were created for option contract {option.Symbol}");
+            }
+            if (orderEvent.Direction == OrderDirection.Sell && option.Holdings.Quantity != 0)
+            {
+                throw new Exception("Holdings were found after a filled option exercise");
+            }
+            if (orderEvent.Direction == OrderDirection.Sell && !orderEvent.Message.Contains("OTM"))
+            {
+                throw new Exception("Contract did not expire OTM");
+            }
+            if (orderEvent.Message.Contains("Exercise"))
+            {
+                throw new Exception("Exercised option, even though it expires OTM");
+            }
+        }
+
+        /// <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)}");
+            }
+        }
+
+        /// <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", "-4.03%"},
+            {"Compounding Annual Return", "-8.595%"},
+            {"Drawdown", "4.000%"},
+            {"Expectancy", "-1"},
+            {"Net Profit", "-4.029%"},
+            {"Sharpe Ratio", "-1.294"},
+            {"Probabilistic Sharpe Ratio", "0.017%"},
+            {"Loss Rate", "100%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "-0.069"},
+            {"Beta", "-0.002"},
+            {"Annual Standard Deviation", "0.053"},
+            {"Annual Variance", "0.003"},
+            {"Information Ratio", "0.911"},
+            {"Tracking Error", "0.182"},
+            {"Treynor Ratio", "28.46"},
+            {"Total Fees", "$3.70"},
+            {"Fitness Score", "0"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "-0.195"},
+            {"Return Over Maximum Drawdown", "-2.134"},
+            {"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", "-1004351165"}
+        };
+    }
+}
+

Algorithm.CSharp/FutureOptionMultipleContractsInDifferentContractMonthsWithSameUnderlyingFutureRegressionAlgorithm.cs

@@ -0,0 +1,147 @@
+/*
+ * 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;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// This regression test tests for the loading of futures options contracts with a contract month of 2020-03 can live
+    /// and be loaded from the same ZIP file that the 2020-04 contract month Future Option contract lives in.
+    /// </summary>
+    public class FutureOptionMultipleContractsInDifferentContractMonthsWithSameUnderlyingFutureRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private readonly Dictionary<Symbol, bool> _expectedSymbols = new Dictionary<Symbol, bool>
+        {
+            { CreateOption(new DateTime(2020, 3, 26), OptionRight.Call, 1650), false },
+            { CreateOption(new DateTime(2020, 3, 26), OptionRight.Put, 1540), false },
+            { CreateOption(new DateTime(2020, 2, 25), OptionRight.Call, 1600), false },
+            { CreateOption(new DateTime(2020, 2, 25), OptionRight.Put, 1545), false }
+        };
+
+        public override void Initialize()
+        {
+            SetStartDate(2020, 1, 5);
+            SetEndDate(2020, 1, 6);
+
+            var goldFutures = AddFuture("GC", Resolution.Minute, Market.COMEX);
+            goldFutures.SetFilter(0, 365);
+
+            AddFutureOption(goldFutures.Symbol);
+        }
+
+        public override void OnData(Slice data)
+        {
+            foreach (var symbol in data.QuoteBars.Keys)
+            {
+                if (_expectedSymbols.ContainsKey(symbol))
+                {
+                    var invested = _expectedSymbols[symbol];
+                    if (!invested)
+                    {
+                        MarketOrder(symbol, 1);
+                    }
+
+                    _expectedSymbols[symbol] = true;
+                }
+            }
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            var notEncountered = _expectedSymbols.Where(kvp => !kvp.Value).ToList();
+            if (notEncountered.Any())
+            {
+                throw new Exception($"Expected all Symbols encountered and invested in, but the following were not found: {string.Join(", ", notEncountered.Select(kvp => kvp.Value.ToStringInvariant()))}");
+            }
+            if (!Portfolio.Invested)
+            {
+                throw new Exception("Expected holdings at the end of algorithm, but none were found.");
+            }
+        }
+
+        private static Symbol CreateOption(DateTime expiry, OptionRight optionRight, decimal strikePrice)
+        {
+            return QuantConnect.Symbol.CreateOption(
+                QuantConnect.Symbol.CreateFuture("GC", Market.COMEX, new DateTime(2020, 4, 28)),
+                Market.COMEX,
+                OptionStyle.American,
+                optionRight,
+                strikePrice,
+                expiry);
+        }
+
+        /// <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%"},
+            {"Compounding Annual Return", "-8.289%"},
+            {"Drawdown", "3.500%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "-0.047%"},
+            {"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", "-14.395"},
+            {"Tracking Error", "0.043"},
+            {"Treynor Ratio", "0"},
+            {"Total Fees", "$7.40"},
+            {"Fitness Score", "0.019"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "79228162514264337593543950335"},
+            {"Return Over Maximum Drawdown", "-194.237"},
+            {"Portfolio Turnover", "0.038"},
+            {"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", "1328857323"}
+        };
+    }
+}

Algorithm.CSharp/FutureOptionPutITMExpiryRegressionAlgorithm.cs

@@ -0,0 +1,249 @@
+/*
+ * 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 In The Money (ITM) future option expiry for puts.
+    /// We expect 3 orders from the algorithm, which are:
+    ///
+    ///   * Initial entry, buy ES Put Option (expiring ITM) (buy, qty 1)
+    ///   * Option exercise, receiving short ES future contracts (sell, qty -1)
+    ///   * Future contract liquidation, due to impending expiry (buy qty 1)
+    ///
+    /// Additionally, we test delistings for future options and assert that our
+    /// portfolio holdings reflect the orders the algorithm has submitted.
+    /// </summary>
+    public class FutureOptionPutITMExpiryRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Symbol _es19m20;
+        private Symbol _esOption;
+        private Symbol _expectedContract;
+
+        public override void Initialize()
+        {
+            SetStartDate(2020, 1, 5);
+            SetEndDate(2020, 6, 30);
+
+            _es19m20 = AddFutureContract(
+                QuantConnect.Symbol.CreateFuture(
+                    Futures.Indices.SP500EMini,
+                    Market.CME,
+                    new DateTime(2020, 6, 19)),
+                Resolution.Minute).Symbol;
+
+            // Select a future option expiring ITM, and adds it to the algorithm.
+            _esOption = AddFutureOptionContract(OptionChainProvider.GetOptionContractList(_es19m20, Time)
+                .Where(x => x.ID.StrikePrice >= 3300m && x.ID.OptionRight == OptionRight.Put)
+                .OrderBy(x => x.ID.StrikePrice)
+                .Take(1)
+                .Single(), Resolution.Minute).Symbol;
+
+            _expectedContract = QuantConnect.Symbol.CreateOption(_es19m20, Market.CME, OptionStyle.American, OptionRight.Put, 3300m, new DateTime(2020, 6, 19));
+            if (_esOption != _expectedContract)
+            {
+                throw new Exception($"Contract {_expectedContract} was not found in the chain");
+            }
+
+            Schedule.On(DateRules.Tomorrow, TimeRules.AfterMarketOpen(_es19m20, 1), () =>
+            {
+                MarketOrder(_esOption, 1);
+            });
+        }
+
+        public override void OnData(Slice data)
+        {
+            // Assert delistings, so that we can make sure that we receive the delisting warnings at
+            // the expected time. These assertions detect bug #4872
+            foreach (var delisting in data.Delistings.Values)
+            {
+                if (delisting.Type == DelistingType.Warning)
+                {
+                    if (delisting.Time != new DateTime(2020, 6, 19))
+                    {
+                        throw new Exception($"Delisting warning issued at unexpected date: {delisting.Time}");
+                    }
+                }
+                if (delisting.Type == DelistingType.Delisted)
+                {
+                    if (delisting.Time != new DateTime(2020, 6, 20))
+                    {
+                        throw new Exception($"Delisting happened at unexpected date: {delisting.Time}");
+                    }
+                }
+            }
+        }
+
+        public override void OnOrderEvent(OrderEvent orderEvent)
+        {
+            if (orderEvent.Status != OrderStatus.Filled)
+            {
+                // There's lots of noise with OnOrderEvent, but we're only interested in fills.
+                return;
+            }
+
+            if (!Securities.ContainsKey(orderEvent.Symbol))
+            {
+                throw new Exception($"Order event Symbol not found in Securities collection: {orderEvent.Symbol}");
+            }
+
+            var security = Securities[orderEvent.Symbol];
+            if (security.Symbol == _es19m20)
+            {
+                AssertFutureOptionOrderExercise(orderEvent, security, Securities[_expectedContract]);
+            }
+            else if (security.Symbol == _expectedContract)
+            {
+                AssertFutureOptionContractOrder(orderEvent, security);
+            }
+            else
+            {
+                throw new Exception($"Received order event for unknown Symbol: {orderEvent.Symbol}");
+            }
+
+            Log($"{Time:yyyy-MM-dd HH:mm:ss} -- {orderEvent.Symbol} :: Price: {Securities[orderEvent.Symbol].Holdings.Price} Qty: {Securities[orderEvent.Symbol].Holdings.Quantity} Direction: {orderEvent.Direction} Msg: {orderEvent.Message}");
+        }
+
+        private void AssertFutureOptionOrderExercise(OrderEvent orderEvent, Security future, Security optionContract)
+        {
+            var expectedLiquidationTimeUtc = new DateTime(2020, 6, 19, 20, 0, 0);
+
+            if (orderEvent.Direction == OrderDirection.Buy && future.Holdings.Quantity != 0)
+            {
+                // We expect the contract to have been liquidated immediately
+                throw new Exception($"Did not liquidate existing holdings for Symbol {future.Symbol}");
+            }
+            if (orderEvent.Direction == OrderDirection.Buy && orderEvent.UtcTime != expectedLiquidationTimeUtc)
+            {
+                throw new Exception($"Liquidated future contract, but not at the expected time. Expected: {expectedLiquidationTimeUtc:yyyy-MM-dd HH:mm:ss} - found {orderEvent.UtcTime:yyyy-MM-dd HH:mm:ss}");
+            }
+
+            // No way to detect option exercise orders or any other kind of special orders
+            // other than matching strings, for now.
+            if (orderEvent.Message.Contains("Option Exercise"))
+            {
+                if (orderEvent.FillPrice != 3300m)
+                {
+                    throw new Exception("Option did not exercise at expected strike price (3300)");
+                }
+                if (future.Holdings.Quantity != -1)
+                {
+                    // Here, we expect to have some holdings in the underlying, but not in the future option anymore.
+                    throw new Exception($"Exercised option contract, but we have no holdings for Future {future.Symbol}");
+                }
+
+                if (optionContract.Holdings.Quantity != 0)
+                {
+                    throw new Exception($"Exercised option contract, but we have holdings for Option contract {optionContract.Symbol}");
+                }
+            }
+        }
+
+        private void AssertFutureOptionContractOrder(OrderEvent orderEvent, Security option)
+        {
+            if (orderEvent.Direction == OrderDirection.Buy && option.Holdings.Quantity != 1)
+            {
+                throw new Exception($"No holdings were created for option contract {option.Symbol}");
+            }
+            if (orderEvent.Direction == OrderDirection.Sell && option.Holdings.Quantity != 0)
+            {
+                throw new Exception($"Holdings were found after a filled option exercise");
+            }
+            if (orderEvent.Message.Contains("Exercise") && option.Holdings.Quantity != 0)
+            {
+                throw new Exception($"Holdings were found after exercising option contract {option.Symbol}");
+            }
+        }
+
+        /// <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)}");
+            }
+        }
+
+        /// <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", "4.15%"},
+            {"Average Loss", "-8.27%"},
+            {"Compounding Annual Return", "-9.486%"},
+            {"Drawdown", "4.500%"},
+            {"Expectancy", "-0.249"},
+            {"Net Profit", "-4.457%"},
+            {"Sharpe Ratio", "-1.412"},
+            {"Probabilistic Sharpe Ratio", "0.002%"},
+            {"Loss Rate", "50%"},
+            {"Win Rate", "50%"},
+            {"Profit-Loss Ratio", "0.50"},
+            {"Alpha", "-0.076"},
+            {"Beta", "-0.002"},
+            {"Annual Standard Deviation", "0.053"},
+            {"Annual Variance", "0.003"},
+            {"Information Ratio", "0.871"},
+            {"Tracking Error", "0.183"},
+            {"Treynor Ratio", "37.798"},
+            {"Total Fees", "$7.40"},
+            {"Fitness Score", "0.008"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "-0.238"},
+            {"Return Over Maximum Drawdown", "-2.128"},
+            {"Portfolio Turnover", "0.024"},
+            {"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", "1657883738"}
+        };
+    }
+}
+

Algorithm.CSharp/FutureOptionPutOTMExpiryRegressionAlgorithm.cs

@@ -0,0 +1,222 @@
+/*
+ * 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 Out of The Money (OTM) future option expiry for puts.
+    /// We expect 2 orders from the algorithm, which are:
+    ///
+    ///   * Initial entry, buy ES Put Option (expiring OTM)
+    ///     - contract expires worthless, not exercised, so never opened a position in the underlying
+    ///
+    ///   * Liquidation of worthless ES Put OTM contract
+    ///
+    /// Additionally, we test delistings for future options and assert that our
+    /// portfolio holdings reflect the orders the algorithm has submitted.
+    /// </summary>
+    /// <remarks>
+    /// Total Trades in regression algorithm should be 1, but expiration is counted as a trade.
+    /// </remarks>
+    public class FutureOptionPutOTMExpiryRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Symbol _es19m20;
+        private Symbol _esOption;
+        private Symbol _expectedContract;
+
+        public override void Initialize()
+        {
+            SetStartDate(2020, 1, 5);
+            SetEndDate(2020, 6, 30);
+
+            _es19m20 = AddFutureContract(
+                QuantConnect.Symbol.CreateFuture(
+                    Futures.Indices.SP500EMini,
+                    Market.CME,
+                    new DateTime(2020, 6, 19)),
+                Resolution.Minute).Symbol;
+
+            // Select a future option expiring ITM, and adds it to the algorithm.
+            _esOption = AddFutureOptionContract(OptionChainProvider.GetOptionContractList(_es19m20, Time)
+                .Where(x => x.ID.StrikePrice <= 3150m && x.ID.OptionRight == OptionRight.Put)
+                .OrderByDescending(x => x.ID.StrikePrice)
+                .Take(1)
+                .Single(), Resolution.Minute).Symbol;
+
+            _expectedContract = QuantConnect.Symbol.CreateOption(_es19m20, Market.CME, OptionStyle.American, OptionRight.Put, 3150m, new DateTime(2020, 6, 19));
+            if (_esOption != _expectedContract)
+            {
+                throw new Exception($"Contract {_expectedContract} was not found in the chain");
+            }
+
+            Schedule.On(DateRules.Tomorrow, TimeRules.AfterMarketOpen(_es19m20, 1), () =>
+            {
+                MarketOrder(_esOption, 1);
+            });
+        }
+
+        public override void OnData(Slice data)
+        {
+            // Assert delistings, so that we can make sure that we receive the delisting warnings at
+            // the expected time. These assertions detect bug #4872
+            foreach (var delisting in data.Delistings.Values)
+            {
+                if (delisting.Type == DelistingType.Warning)
+                {
+                    if (delisting.Time != new DateTime(2020, 6, 19))
+                    {
+                        throw new Exception($"Delisting warning issued at unexpected date: {delisting.Time}");
+                    }
+                }
+                if (delisting.Type == DelistingType.Delisted)
+                {
+                    if (delisting.Time != new DateTime(2020, 6, 20))
+                    {
+                        throw new Exception($"Delisting happened at unexpected date: {delisting.Time}");
+                    }
+                }
+            }
+        }
+
+        public override void OnOrderEvent(OrderEvent orderEvent)
+        {
+            if (orderEvent.Status != OrderStatus.Filled)
+            {
+                // There's lots of noise with OnOrderEvent, but we're only interested in fills.
+                return;
+            }
+
+            if (!Securities.ContainsKey(orderEvent.Symbol))
+            {
+                throw new Exception($"Order event Symbol not found in Securities collection: {orderEvent.Symbol}");
+            }
+
+            var security = Securities[orderEvent.Symbol];
+            if (security.Symbol == _es19m20)
+            {
+                throw new Exception("Invalid state: did not expect a position for the underlying to be opened, since this contract expires OTM");
+            }
+            if (security.Symbol == _expectedContract)
+            {
+                AssertFutureOptionContractOrder(orderEvent, security);
+            }
+            else
+            {
+                throw new Exception($"Received order event for unknown Symbol: {orderEvent.Symbol}");
+            }
+
+            Log($"{orderEvent}");
+        }
+
+        private void AssertFutureOptionContractOrder(OrderEvent orderEvent, Security option)
+        {
+            if (orderEvent.Direction == OrderDirection.Buy && option.Holdings.Quantity != 1)
+            {
+                throw new Exception($"No holdings were created for option contract {option.Symbol}");
+            }
+            if (orderEvent.Direction == OrderDirection.Sell && option.Holdings.Quantity != 0)
+            {
+                throw new Exception("Holdings were found after a filled option exercise");
+            }
+            if (orderEvent.Direction == OrderDirection.Sell && !orderEvent.Message.Contains("OTM"))
+            {
+                throw new Exception("Contract did not expire OTM");
+            }
+            if (orderEvent.Message.Contains("Exercise"))
+            {
+                throw new Exception("Exercised option, even though it expires OTM");
+            }
+        }
+
+        /// <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)}");
+            }
+        }
+
+        /// <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", "-5.12%"},
+            {"Compounding Annual Return", "-10.844%"},
+            {"Drawdown", "5.100%"},
+            {"Expectancy", "-1"},
+            {"Net Profit", "-5.116%"},
+            {"Sharpe Ratio", "-1.28"},
+            {"Probabilistic Sharpe Ratio", "0.017%"},
+            {"Loss Rate", "100%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "-0.086"},
+            {"Beta", "-0.003"},
+            {"Annual Standard Deviation", "0.067"},
+            {"Annual Variance", "0.004"},
+            {"Information Ratio", "0.794"},
+            {"Tracking Error", "0.187"},
+            {"Treynor Ratio", "28.078"},
+            {"Total Fees", "$3.70"},
+            {"Fitness Score", "0"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "-0.193"},
+            {"Return Over Maximum Drawdown", "-2.12"},
+            {"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", "-49211561"}
+        };
+    }
+}
+

Algorithm.CSharp/FutureOptionShortCallITMExpiryRegressionAlgorithm.cs

@@ -0,0 +1,233 @@
+/*
+ * 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 In The Money (ITM) future option expiry for short calls.
+    /// We expect 3 orders from the algorithm, which are:
+    ///
+    ///   * Initial entry, sell ES Call Option (expiring ITM)
+    ///   * Option assignment, sell 1 contract of the underlying (ES)
+    ///   * Future contract expiry, liquidation (buy 1 ES future)
+    ///
+    /// Additionally, we test delistings for future options and assert that our
+    /// portfolio holdings reflect the orders the algorithm has submitted.
+    /// </summary>
+    public class FutureOptionShortCallITMExpiryRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Symbol _es19m20;
+        private Symbol _esOption;
+        private Symbol _expectedContract;
+
+        public override void Initialize()
+        {
+            SetStartDate(2020, 1, 5);
+            SetEndDate(2020, 6, 30);
+
+            _es19m20 = AddFutureContract(
+                QuantConnect.Symbol.CreateFuture(
+                    Futures.Indices.SP500EMini,
+                    Market.CME,
+                    new DateTime(2020, 6, 19)),
+                Resolution.Minute).Symbol;
+
+            // Select a future option expiring ITM, and adds it to the algorithm.
+            _esOption = AddFutureOptionContract(OptionChainProvider.GetOptionContractList(_es19m20, Time)
+                .Where(x => x.ID.StrikePrice <= 3100m && x.ID.OptionRight == OptionRight.Call)
+                .OrderByDescending(x => x.ID.StrikePrice)
+                .Take(1)
+                .Single(), Resolution.Minute).Symbol;
+
+            _expectedContract = QuantConnect.Symbol.CreateOption(_es19m20, Market.CME, OptionStyle.American, OptionRight.Call, 3100m, new DateTime(2020, 6, 19));
+            if (_esOption != _expectedContract)
+            {
+                throw new Exception($"Contract {_expectedContract} was not found in the chain");
+            }
+
+            Schedule.On(DateRules.Tomorrow, TimeRules.AfterMarketOpen(_es19m20, 1), () =>
+            {
+                MarketOrder(_esOption, -1);
+            });
+        }
+
+        public override void OnData(Slice data)
+        {
+            // Assert delistings, so that we can make sure that we receive the delisting warnings at
+            // the expected time. These assertions detect bug #4872
+            foreach (var delisting in data.Delistings.Values)
+            {
+                if (delisting.Type == DelistingType.Warning)
+                {
+                    if (delisting.Time != new DateTime(2020, 6, 19))
+                    {
+                        throw new Exception($"Delisting warning issued at unexpected date: {delisting.Time}");
+                    }
+                }
+                if (delisting.Type == DelistingType.Delisted)
+                {
+                    if (delisting.Time != new DateTime(2020, 6, 20))
+                    {
+                        throw new Exception($"Delisting happened at unexpected date: {delisting.Time}");
+                    }
+                }
+            }
+        }
+
+        public override void OnOrderEvent(OrderEvent orderEvent)
+        {
+            if (orderEvent.Status != OrderStatus.Filled)
+            {
+                // There's lots of noise with OnOrderEvent, but we're only interested in fills.
+                return;
+            }
+
+            if (!Securities.ContainsKey(orderEvent.Symbol))
+            {
+                throw new Exception($"Order event Symbol not found in Securities collection: {orderEvent.Symbol}");
+            }
+
+            var security = Securities[orderEvent.Symbol];
+            if (security.Symbol == _es19m20)
+            {
+                AssertFutureOptionOrderExercise(orderEvent, security, Securities[_expectedContract]);
+            }
+            else if (security.Symbol == _expectedContract)
+            {
+                AssertFutureOptionContractOrder(orderEvent, security);
+            }
+            else
+            {
+                throw new Exception($"Received order event for unknown Symbol: {orderEvent.Symbol}");
+            }
+
+            Log($"{orderEvent}");
+        }
+
+        private void AssertFutureOptionOrderExercise(OrderEvent orderEvent, Security future, Security optionContract)
+        {
+            if (orderEvent.Message.Contains("Assignment"))
+            {
+                if (orderEvent.FillPrice != 3100m)
+                {
+                    throw new Exception("Option was not assigned at expected strike price (3100)");
+                }
+                if (orderEvent.Direction != OrderDirection.Sell || future.Holdings.Quantity != -1)
+                {
+                    throw new Exception($"Expected Qty: -1 futures holdings for assigned future {future.Symbol}, found {future.Holdings.Quantity}");
+                }
+
+                return;
+            }
+
+            if (orderEvent.Direction == OrderDirection.Buy && future.Holdings.Quantity != 0)
+            {
+                // We buy back the underlying at expiration, so we expect a neutral position then
+                throw new Exception($"Expected no holdings when liquidating future contract {future.Symbol}");
+            }
+        }
+
+        private void AssertFutureOptionContractOrder(OrderEvent orderEvent, Security option)
+        {
+            if (orderEvent.Direction == OrderDirection.Sell && option.Holdings.Quantity != -1)
+            {
+                throw new Exception($"No holdings were created for option contract {option.Symbol}");
+            }
+            if (orderEvent.IsAssignment && option.Holdings.Quantity != 0)
+            {
+                throw new Exception($"Holdings were found after option contract was assigned: {option.Symbol}");
+            }
+        }
+
+        /// <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)}");
+            }
+        }
+
+        /// <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", "10.05%"},
+            {"Average Loss", "-5.63%"},
+            {"Compounding Annual Return", "8.619%"},
+            {"Drawdown", "0.500%"},
+            {"Expectancy", "0.393"},
+            {"Net Profit", "3.855%"},
+            {"Sharpe Ratio", "1.212"},
+            {"Probabilistic Sharpe Ratio", "59.039%"},
+            {"Loss Rate", "50%"},
+            {"Win Rate", "50%"},
+            {"Profit-Loss Ratio", "1.79"},
+            {"Alpha", "0.071"},
+            {"Beta", "0.003"},
+            {"Annual Standard Deviation", "0.058"},
+            {"Annual Variance", "0.003"},
+            {"Information Ratio", "1.663"},
+            {"Tracking Error", "0.183"},
+            {"Treynor Ratio", "22.266"},
+            {"Total Fees", "$7.40"},
+            {"Fitness Score", "0.021"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "79228162514264337593543950335"},
+            {"Return Over Maximum Drawdown", "18.319"},
+            {"Portfolio Turnover", "0.021"},
+            {"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", "-120798310"}
+        };
+    }
+}
+

Algorithm.CSharp/FutureOptionShortCallOTMExpiryRegressionAlgorithm.cs

@@ -0,0 +1,216 @@
+/*
+ * 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 Out of The Money (OTM) future option expiry for short calls.
+    /// We expect 2 orders from the algorithm, which are:
+    ///
+    ///   * Initial entry, sell ES Call Option (expiring OTM)
+    ///     - Profit the option premium, since the option was not assigned.
+    ///
+    ///   * Liquidation of ES call OTM contract on the last trade date
+    ///
+    /// Additionally, we test delistings for future options and assert that our
+    /// portfolio holdings reflect the orders the algorithm has submitted.
+    /// </summary>
+    public class FutureOptionShortCallOTMExpiryRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Symbol _es19m20;
+        private Symbol _esOption;
+        private Symbol _expectedContract;
+
+        public override void Initialize()
+        {
+            SetStartDate(2020, 1, 5);
+            SetEndDate(2020, 6, 30);
+
+            _es19m20 = AddFutureContract(
+                QuantConnect.Symbol.CreateFuture(
+                    Futures.Indices.SP500EMini,
+                    Market.CME,
+                    new DateTime(2020, 6, 19)),
+                Resolution.Minute).Symbol;
+
+            // Select a future option expiring ITM, and adds it to the algorithm.
+            _esOption = AddFutureOptionContract(OptionChainProvider.GetOptionContractList(_es19m20, Time)
+                .Where(x => x.ID.StrikePrice >= 3400m && x.ID.OptionRight == OptionRight.Call)
+                .OrderBy(x => x.ID.StrikePrice)
+                .Take(1)
+                .Single(), Resolution.Minute).Symbol;
+
+            _expectedContract = QuantConnect.Symbol.CreateOption(_es19m20, Market.CME, OptionStyle.American, OptionRight.Call, 3400m, new DateTime(2020, 6, 19));
+            if (_esOption != _expectedContract)
+            {
+                throw new Exception($"Contract {_expectedContract} was not found in the chain");
+            }
+
+            Schedule.On(DateRules.Tomorrow, TimeRules.AfterMarketOpen(_es19m20, 1), () =>
+            {
+                MarketOrder(_esOption, -1);
+            });
+        }
+
+        public override void OnData(Slice data)
+        {
+            // Assert delistings, so that we can make sure that we receive the delisting warnings at
+            // the expected time. These assertions detect bug #4872
+            foreach (var delisting in data.Delistings.Values)
+            {
+                if (delisting.Type == DelistingType.Warning)
+                {
+                    if (delisting.Time != new DateTime(2020, 6, 19))
+                    {
+                        throw new Exception($"Delisting warning issued at unexpected date: {delisting.Time}");
+                    }
+                }
+                if (delisting.Type == DelistingType.Delisted)
+                {
+                    if (delisting.Time != new DateTime(2020, 6, 20))
+                    {
+                        throw new Exception($"Delisting happened at unexpected date: {delisting.Time}");
+                    }
+                }
+            }
+        }
+
+        public override void OnOrderEvent(OrderEvent orderEvent)
+        {
+            if (orderEvent.Status != OrderStatus.Filled)
+            {
+                // There's lots of noise with OnOrderEvent, but we're only interested in fills.
+                return;
+            }
+
+            if (!Securities.ContainsKey(orderEvent.Symbol))
+            {
+                throw new Exception($"Order event Symbol not found in Securities collection: {orderEvent.Symbol}");
+            }
+
+            var security = Securities[orderEvent.Symbol];
+            if (security.Symbol == _es19m20)
+            {
+                throw new Exception($"Expected no order events for underlying Symbol {security.Symbol}");
+            }
+
+            if (security.Symbol == _expectedContract)
+            {
+                AssertFutureOptionContractOrder(orderEvent, security);
+            }
+            else
+            {
+                throw new Exception($"Received order event for unknown Symbol: {orderEvent.Symbol}");
+            }
+
+            Log($"{orderEvent}");
+        }
+
+        private void AssertFutureOptionContractOrder(OrderEvent orderEvent, Security optionContract)
+        {
+            if (orderEvent.Direction == OrderDirection.Sell && optionContract.Holdings.Quantity != -1)
+            {
+                throw new Exception($"No holdings were created for option contract {optionContract.Symbol}");
+            }
+            if (orderEvent.Direction == OrderDirection.Buy && optionContract.Holdings.Quantity != 0)
+            {
+                throw new Exception("Expected no options holdings after closing position");
+            }
+            if (orderEvent.IsAssignment)
+            {
+                throw new Exception($"Assignment was not expected for {orderEvent.Symbol}");
+            }
+        }
+
+        /// <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)}");
+            }
+        }
+
+        /// <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", "1.81%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "3.996%"},
+            {"Drawdown", "0.000%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "1.809%"},
+            {"Sharpe Ratio", "1.315"},
+            {"Probabilistic Sharpe Ratio", "66.818%"},
+            {"Loss Rate", "0%"},
+            {"Win Rate", "100%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "0.032"},
+            {"Beta", "0.001"},
+            {"Annual Standard Deviation", "0.024"},
+            {"Annual Variance", "0.001"},
+            {"Information Ratio", "1.516"},
+            {"Tracking Error", "0.176"},
+            {"Treynor Ratio", "27.339"},
+            {"Total Fees", "$3.70"},
+            {"Fitness Score", "0"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "79228162514264337593543950335"},
+            {"Return Over Maximum Drawdown", "101.571"},
+            {"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", "-404864705"}
+        };
+    }
+}
+

Algorithm.CSharp/FutureOptionShortPutITMExpiryRegressionAlgorithm.cs

@@ -0,0 +1,230 @@
+/*
+ * 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 In The Money (ITM) future option expiry for short puts.
+    /// We expect 3 orders from the algorithm, which are:
+    ///
+    ///   * Initial entry, sell ES Put Option (expiring ITM)
+    ///   * Option assignment, buy 1 contract of the underlying (ES)
+    ///   * Future contract expiry, liquidation (sell 1 ES future)
+    ///
+    /// Additionally, we test delistings for future options and assert that our
+    /// portfolio holdings reflect the orders the algorithm has submitted.
+    /// </summary>
+    public class FutureOptionShortPutITMExpiryRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Symbol _es19m20;
+        private Symbol _esOption;
+        private Symbol _expectedContract;
+
+        public override void Initialize()
+        {
+            SetStartDate(2020, 1, 5);
+            SetEndDate(2020, 6, 30);
+
+            _es19m20 = AddFutureContract(
+                QuantConnect.Symbol.CreateFuture(
+                    Futures.Indices.SP500EMini,
+                    Market.CME,
+                    new DateTime(2020, 6, 19)),
+                Resolution.Minute).Symbol;
+
+            // Select a future option expiring ITM, and adds it to the algorithm.
+            _esOption = AddFutureOptionContract(OptionChainProvider.GetOptionContractList(_es19m20, Time)
+                .Where(x => x.ID.StrikePrice <= 3400m && x.ID.OptionRight == OptionRight.Put)
+                .OrderByDescending(x => x.ID.StrikePrice)
+                .Take(1)
+                .Single(), Resolution.Minute).Symbol;
+
+            _expectedContract = QuantConnect.Symbol.CreateOption(_es19m20, Market.CME, OptionStyle.American, OptionRight.Put, 3400m, new DateTime(2020, 6, 19));
+            if (_esOption != _expectedContract)
+            {
+                throw new Exception($"Contract {_expectedContract} was not found in the chain");
+            }
+
+            Schedule.On(DateRules.Tomorrow, TimeRules.AfterMarketOpen(_es19m20, 1), () =>
+            {
+                MarketOrder(_esOption, -1);
+            });
+        }
+
+        public override void OnData(Slice data)
+        {
+            // Assert delistings, so that we can make sure that we receive the delisting warnings at
+            // the expected time. These assertions detect bug #4872
+            foreach (var delisting in data.Delistings.Values)
+            {
+                if (delisting.Type == DelistingType.Warning)
+                {
+                    if (delisting.Time != new DateTime(2020, 6, 19))
+                    {
+                        throw new Exception($"Delisting warning issued at unexpected date: {delisting.Time}");
+                    }
+                }
+                if (delisting.Type == DelistingType.Delisted)
+                {
+                    if (delisting.Time != new DateTime(2020, 6, 20))
+                    {
+                        throw new Exception($"Delisting happened at unexpected date: {delisting.Time}");
+                    }
+                }
+            }
+        }
+
+        public override void OnOrderEvent(OrderEvent orderEvent)
+        {
+            if (orderEvent.Status != OrderStatus.Filled)
+            {
+                // There's lots of noise with OnOrderEvent, but we're only interested in fills.
+                return;
+            }
+
+            if (!Securities.ContainsKey(orderEvent.Symbol))
+            {
+                throw new Exception($"Order event Symbol not found in Securities collection: {orderEvent.Symbol}");
+            }
+
+            var security = Securities[orderEvent.Symbol];
+            if (security.Symbol == _es19m20)
+            {
+                AssertFutureOptionOrderExercise(orderEvent, security, Securities[_expectedContract]);
+            }
+            else if (security.Symbol == _expectedContract)
+            {
+                AssertFutureOptionContractOrder(orderEvent, security);
+            }
+            else
+            {
+                throw new Exception($"Received order event for unknown Symbol: {orderEvent.Symbol}");
+            }
+
+            Log($"{orderEvent}");
+        }
+
+        private void AssertFutureOptionOrderExercise(OrderEvent orderEvent, Security future, Security optionContract)
+        {
+            if (orderEvent.Message.Contains("Assignment"))
+            {
+                if (orderEvent.FillPrice != 3400)
+                {
+                    throw new Exception("Option was not assigned at expected strike price (3400)");
+                }
+                if (orderEvent.Direction != OrderDirection.Buy || future.Holdings.Quantity != 1)
+                {
+                    throw new Exception($"Expected Qty: 1 futures holdings for assigned future {future.Symbol}, found {future.Holdings.Quantity}");
+                }
+            }
+            if (!orderEvent.Message.Contains("Assignment") && orderEvent.Direction == OrderDirection.Sell && future.Holdings.Quantity != 0)
+            {
+                // We buy back the underlying at expiration, so we expect a neutral position then
+                throw new Exception($"Expected no holdings when liquidating future contract {future.Symbol}");
+            }
+        }
+
+        private void AssertFutureOptionContractOrder(OrderEvent orderEvent, Security option)
+        {
+            if (orderEvent.Direction == OrderDirection.Sell && option.Holdings.Quantity != -1)
+            {
+                throw new Exception($"No holdings were created for option contract {option.Symbol}");
+            }
+            if (orderEvent.IsAssignment && option.Holdings.Quantity != 0)
+            {
+                throw new Exception($"Holdings were found after option contract was assigned: {option.Symbol}");
+            }
+        }
+
+        /// <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)}");
+            }
+        }
+
+        /// <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", "10.18%"},
+            {"Average Loss", "-8.05%"},
+            {"Compounding Annual Return", "2.902%"},
+            {"Drawdown", "0.500%"},
+            {"Expectancy", "0.133"},
+            {"Net Profit", "1.318%"},
+            {"Sharpe Ratio", "0.95"},
+            {"Probabilistic Sharpe Ratio", "47.360%"},
+            {"Loss Rate", "50%"},
+            {"Win Rate", "50%"},
+            {"Profit-Loss Ratio", "1.27"},
+            {"Alpha", "0.024"},
+            {"Beta", "0.002"},
+            {"Annual Standard Deviation", "0.025"},
+            {"Annual Variance", "0.001"},
+            {"Information Ratio", "1.467"},
+            {"Tracking Error", "0.176"},
+            {"Treynor Ratio", "14.729"},
+            {"Total Fees", "$7.40"},
+            {"Fitness Score", "0.022"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "79228162514264337593543950335"},
+            {"Return Over Maximum Drawdown", "6.087"},
+            {"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", "-1218521879"}
+        };
+    }
+}
+

Algorithm.CSharp/FutureOptionShortPutOTMExpiryRegressionAlgorithm.cs

@@ -0,0 +1,215 @@
+/*
+ * 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 Out of The Money (OTM) future option expiry for short puts.
+    /// We expect 2 order from the algorithm, which are:
+    ///
+    ///   * Initial entry, sell ES Put Option (expiring OTM)
+    ///     - Profit the option premium, since the option was not assigned.
+    ///
+    ///   * Liquidation of ES put OTM contract on the last trade date
+    ///
+    /// Additionally, we test delistings for future options and assert that our
+    /// portfolio holdings reflect the orders the algorithm has submitted.
+    /// </summary>
+    public class FutureOptionShortPutOTMExpiryRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Symbol _es19m20;
+        private Symbol _esOption;
+        private Symbol _expectedContract;
+
+        public override void Initialize()
+        {
+            SetStartDate(2020, 1, 5);
+            SetEndDate(2020, 6, 30);
+
+            _es19m20 = AddFutureContract(
+                QuantConnect.Symbol.CreateFuture(
+                    Futures.Indices.SP500EMini,
+                    Market.CME,
+                    new DateTime(2020, 6, 19)),
+                Resolution.Minute).Symbol;
+
+            // Select a future option expiring ITM, and adds it to the algorithm.
+            _esOption = AddFutureOptionContract(OptionChainProvider.GetOptionContractList(_es19m20, Time)
+                .Where(x => x.ID.StrikePrice <= 3000m && x.ID.OptionRight == OptionRight.Put)
+                .OrderByDescending(x => x.ID.StrikePrice)
+                .Take(1)
+                .Single(), Resolution.Minute).Symbol;
+
+            _expectedContract = QuantConnect.Symbol.CreateOption(_es19m20, Market.CME, OptionStyle.American, OptionRight.Put, 3000m, new DateTime(2020, 6, 19));
+            if (_esOption != _expectedContract)
+            {
+                throw new Exception($"Contract {_expectedContract} was not found in the chain");
+            }
+
+            Schedule.On(DateRules.Tomorrow, TimeRules.AfterMarketOpen(_es19m20, 1), () =>
+            {
+                MarketOrder(_esOption, -1);
+            });
+        }
+
+        public override void OnData(Slice data)
+        {
+            // Assert delistings, so that we can make sure that we receive the delisting warnings at
+            // the expected time. These assertions detect bug #4872
+            foreach (var delisting in data.Delistings.Values)
+            {
+                if (delisting.Type == DelistingType.Warning)
+                {
+                    if (delisting.Time != new DateTime(2020, 6, 19))
+                    {
+                        throw new Exception($"Delisting warning issued at unexpected date: {delisting.Time}");
+                    }
+                }
+                if (delisting.Type == DelistingType.Delisted)
+                {
+                    if (delisting.Time != new DateTime(2020, 6, 20))
+                    {
+                        throw new Exception($"Delisting happened at unexpected date: {delisting.Time}");
+                    }
+                }
+            }
+        }
+
+        public override void OnOrderEvent(OrderEvent orderEvent)
+        {
+            if (orderEvent.Status != OrderStatus.Filled)
+            {
+                // There's lots of noise with OnOrderEvent, but we're only interested in fills.
+                return;
+            }
+
+            if (!Securities.ContainsKey(orderEvent.Symbol))
+            {
+                throw new Exception($"Order event Symbol not found in Securities collection: {orderEvent.Symbol}");
+            }
+
+            var security = Securities[orderEvent.Symbol];
+            if (security.Symbol == _es19m20)
+            {
+                throw new Exception($"Expected no order events for underlying Symbol {security.Symbol}");
+            }
+            if (security.Symbol == _expectedContract)
+            {
+                AssertFutureOptionContractOrder(orderEvent, security);
+            }
+            else
+            {
+                throw new Exception($"Received order event for unknown Symbol: {orderEvent.Symbol}");
+            }
+
+            Log($"{orderEvent}");
+        }
+
+        private void AssertFutureOptionContractOrder(OrderEvent orderEvent, Security option)
+        {
+            if (orderEvent.Direction == OrderDirection.Sell && option.Holdings.Quantity != -1)
+            {
+                throw new Exception($"No holdings were created for option contract {option.Symbol}");
+            }
+            if (orderEvent.Direction == OrderDirection.Buy && option.Holdings.Quantity != 0)
+            {
+                throw new Exception("Expected no options holdings after closing position");
+            }
+            if (orderEvent.IsAssignment)
+            {
+                throw new Exception($"Assignment was not expected for {orderEvent.Symbol}");
+            }
+        }
+
+        /// <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)}");
+            }
+        }
+
+        /// <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", "3.28%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "7.317%"},
+            {"Drawdown", "0.000%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "3.284%"},
+            {"Sharpe Ratio", "1.343"},
+            {"Probabilistic Sharpe Ratio", "67.503%"},
+            {"Loss Rate", "0%"},
+            {"Win Rate", "100%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "0.06"},
+            {"Beta", "0.002"},
+            {"Annual Standard Deviation", "0.044"},
+            {"Annual Variance", "0.002"},
+            {"Information Ratio", "1.636"},
+            {"Tracking Error", "0.179"},
+            {"Treynor Ratio", "28.253"},
+            {"Total Fees", "$3.70"},
+            {"Fitness Score", "0"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "79228162514264337593543950335"},
+            {"Return Over Maximum Drawdown", "160.505"},
+            {"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", "-2019978457"}
+        };
+    }
+}
+

Algorithm.CSharp/FuturesAndFuturesOptionsExpiryTimeAndLiquidationRegressionAlgorithm.cs

@@ -0,0 +1,198 @@
+/*
+ * 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.Interfaces;
+using QuantConnect.Orders;
+using QuantConnect.Securities;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Tests delistings for Futures and Futures Options to ensure that they are delisted at the expected times.
+    /// </summary>
+    public class FuturesAndFuturesOptionsExpiryTimeAndLiquidationRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private bool _invested;
+        private int _liquidated;
+        private int _delistingsReceived;
+
+        private Symbol _esFuture;
+        private Symbol _esFutureOption;
+
+        private readonly DateTime _expectedExpiryWarningTime = new DateTime(2020, 6, 19);
+        private readonly DateTime _expectedExpiryDelistingTime = new DateTime(2020, 6, 20);
+        private readonly DateTime _expectedLiquidationTime = new DateTime(2020, 6, 19, 16, 0, 0);
+
+        public override void Initialize()
+        {
+            SetStartDate(2020, 1, 5);
+            SetEndDate(2020, 12, 1);
+            SetCash(100000);
+
+            var es = QuantConnect.Symbol.CreateFuture(
+                Futures.Indices.SP500EMini,
+                Market.CME,
+                new DateTime(2020, 6, 19));
+
+            var esOption = QuantConnect.Symbol.CreateOption(
+                es,
+                Market.CME,
+                OptionStyle.American,
+                OptionRight.Put,
+                3400m,
+                new DateTime(2020, 6, 19));
+
+            _esFuture = AddFutureContract(es, Resolution.Minute).Symbol;
+            _esFutureOption = AddFutureOptionContract(esOption, Resolution.Minute).Symbol;
+        }
+
+        public override void OnData(Slice data)
+        {
+            foreach (var delisting in data.Delistings.Values)
+            {
+                // Two warnings and two delisted events should be received for a grand total of 4 events.
+                _delistingsReceived++;
+
+                if (delisting.Type == DelistingType.Warning &&
+                    delisting.Time != _expectedExpiryWarningTime)
+                {
+                    throw new Exception($"Expiry warning with time {delisting.Time} but is expected to be {_expectedExpiryWarningTime}");
+                }
+                if (delisting.Type == DelistingType.Warning && delisting.Time != Time.Date)
+                {
+                    throw new Exception($"Delisting warning received at an unexpected date: {Time} - expected {delisting.Time}");
+                }
+                if (delisting.Type == DelistingType.Delisted &&
+                    delisting.Time != _expectedExpiryDelistingTime)
+                {
+                    throw new Exception($"Delisting occurred at unexpected time: {delisting.Time} - expected: {_expectedExpiryDelistingTime}");
+                }
+                if (delisting.Type == DelistingType.Delisted &&
+                    delisting.Time != Time.Date)
+                {
+                    throw new Exception($"Delisting notice received at an unexpected date: {Time} - expected {delisting.Time}");
+                }
+            }
+
+            if (!_invested &&
+                (data.Bars.ContainsKey(_esFuture) || data.QuoteBars.ContainsKey(_esFuture)) &&
+                (data.Bars.ContainsKey(_esFutureOption) || data.QuoteBars.ContainsKey(_esFutureOption)))
+            {
+                _invested = true;
+
+                MarketOrder(_esFuture, 1);
+                MarketOrder(_esFutureOption, 1);
+            }
+        }
+
+        public override void OnOrderEvent(OrderEvent orderEvent)
+        {
+            if (orderEvent.Direction != OrderDirection.Sell || orderEvent.Status != OrderStatus.Filled)
+            {
+                return;
+            }
+
+            // * Future Liquidation
+            // * Future Option Exercise
+
+            // * We expect NO Underlying Future Liquidation because we already hold a Long future position so the FOP Put selling leaves us breakeven
+            _liquidated++;
+            if (orderEvent.Symbol.SecurityType == SecurityType.FutureOption && _expectedLiquidationTime != Time)
+            {
+                throw new Exception($"Expected to liquidate option {orderEvent.Symbol} at {_expectedLiquidationTime}, instead liquidated at {Time}");
+            }
+            if (orderEvent.Symbol.SecurityType == SecurityType.Future && _expectedLiquidationTime.AddMinutes(-1) != Time && _expectedLiquidationTime != Time)
+            {
+                throw new Exception($"Expected to liquidate future {orderEvent.Symbol} at {_expectedLiquidationTime} (+1 minute), instead liquidated at {Time}");
+            }
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            if (!_invested)
+            {
+                throw new Exception("Never invested in ES futures and FOPs");
+            }
+            if (_delistingsReceived != 4)
+            {
+                throw new Exception($"Expected 4 delisting events received, found: {_delistingsReceived}");
+            }
+            if (_liquidated != 2)
+            {
+                throw new Exception($"Expected 3 liquidation events, found {_liquidated}");
+            }
+        }
+
+        /// <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", "10.15%"},
+            {"Average Loss", "-11.34%"},
+            {"Compounding Annual Return", "-5.054%"},
+            {"Drawdown", "2.300%"},
+            {"Expectancy", "-0.053"},
+            {"Net Profit", "-2.345%"},
+            {"Sharpe Ratio", "-1.289"},
+            {"Probabilistic Sharpe Ratio", "0.028%"},
+            {"Loss Rate", "50%"},
+            {"Win Rate", "50%"},
+            {"Profit-Loss Ratio", "0.89"},
+            {"Alpha", "-0.031"},
+            {"Beta", "-0.001"},
+            {"Annual Standard Deviation", "0.024"},
+            {"Annual Variance", "0.001"},
+            {"Information Ratio", "1.155"},
+            {"Tracking Error", "0.176"},
+            {"Treynor Ratio", "29.128"},
+            {"Total Fees", "$7.40"},
+            {"Fitness Score", "0.007"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "-0.354"},
+            {"Return Over Maximum Drawdown", "-2.155"},
+            {"Portfolio Turnover", "0.024"},
+            {"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", "2109976361"}
+        };
+    }
+}

Algorithm.CSharp/HistoryWithSymbolChangesRegressionAlgorithm.cs

@@ -53,7 +53,7 @@ namespace QuantConnect.Algorithm.CSharp
             }
 
             var firstBar = history.First().Bars.GetValue(symbol);
-            if (firstBar.EndTime != new DateTime(1998, 3, 3) || firstBar.Close != 26.3607004m)
+            if (firstBar.EndTime != new DateTime(1998, 3, 3) || firstBar.Close != 25.11427695m)
             {
                 throw new Exception("First History bar - unexpected data received");
             }

Algorithm.CSharp/HourResolutionMappingEventRegressionAlgorithm.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.Collections.Generic;
+using QuantConnect.Data;
+using QuantConnect.Data.Market;
+using QuantConnect.Interfaces;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Regression algorithm reproducing GH issue #5232
+    /// </summary>
+    public class HourResolutionMappingEventRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private DateTime _dateTime;
+        private SymbolChangedEvent _changedEvent;
+
+        /// <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(2008, 08, 20);
+            SetEndDate(2008, 10, 1);
+
+            AddEquity("SPWR", Resolution.Hour, fillDataForward:false);
+        }
+
+        /// <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)
+        {
+            _dateTime = Time.Date;
+            if (!Portfolio.Invested)
+            {
+                SetHoldings("SPWR", 1);
+            }
+
+            foreach (var symbolChangedEvent in data.SymbolChangedEvents.Values)
+            {
+                _changedEvent = symbolChangedEvent;
+                Log($"{Time}: {symbolChangedEvent.OldSymbol} -> {symbolChangedEvent.NewSymbol}");
+            }
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            if (_dateTime != EndDate.Date)
+            {
+                throw new Exception($"Last day was {_dateTime}, should be algorithm end date: {EndDate.Date}");
+            }
+            if (_changedEvent == null)
+            {
+                throw new Exception("We got not symbol change event! 'SPWR' should of been mapped");
+            }
+        }
+
+        /// <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", "-78.316%"},
+            {"Drawdown", "31.700%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "-16.363%"},
+            {"Sharpe Ratio", "-0.506"},
+            {"Probabilistic Sharpe Ratio", "27.578%"},
+            {"Loss Rate", "0%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "0.431"},
+            {"Beta", "1.976"},
+            {"Annual Standard Deviation", "1.118"},
+            {"Annual Variance", "1.25"},
+            {"Information Ratio", "-0.071"},
+            {"Tracking Error", "0.866"},
+            {"Treynor Ratio", "-0.286"},
+            {"Total Fees", "$5.40"},
+            {"Fitness Score", "0.008"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "-1.038"},
+            {"Return Over Maximum Drawdown", "-2.536"},
+            {"Portfolio Turnover", "0.033"},
+            {"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", "1990864398"}
+        };
+    }
+}

Algorithm.CSharp/HourReverseSplitRegressionAlgorithm.cs

@@ -35,7 +35,7 @@ namespace QuantConnect.Algorithm.CSharp
             SetCash(100000);
             SetBenchmark(x => 0);
 
-            _symbol = AddEquity("VXX", Resolution.Hour).Symbol;
+            _symbol = AddEquity("VXX.1", Resolution.Hour).Symbol;
         }
 
         public void OnData(TradeBars tradeBars)
@@ -103,7 +103,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "1795141360"}
+            {"OrderListHash", "105744170"}
         };
     }
 }

Algorithm.CSharp/MACDTrendAlgorithm.cs

@@ -116,7 +116,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Annual Variance", "0.013"},
             {"Information Ratio", "-0.234"},
             {"Tracking Error", "0.214"},
-            {"Treynor Ratio", "-0.775"},
+            {"Treynor Ratio", "-0.774"},
             {"Total Fees", "$443.74"},
             {"Fitness Score", "0.013"},
             {"Kelly Criterion Estimate", "0"},

Algorithm.CSharp/MarginRemainingRegressionAlgorithm.cs

@@ -103,7 +103,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Annual Variance", "0.038"},
             {"Information Ratio", "0.262"},
             {"Tracking Error", "0.346"},
-            {"Treynor Ratio", "-0.862"},
+            {"Treynor Ratio", "-0.863"},
             {"Total Fees", "$13.69"},
             {"Fitness Score", "0"},
             {"Kelly Criterion Estimate", "0"},

Algorithm.CSharp/OnOrderEventExceptionRegression.cs

@@ -0,0 +1,82 @@
+/*
+ * 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.Interfaces;
+using QuantConnect.Orders;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Regression Algorithm for testing engine behavior with throwing errors in OnOrderEvent
+    /// Should result in a RunTimeError status.
+    /// Reference GH Issue #4947
+    /// </summary>
+    public class OnOrderEventExceptionRegression : 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);
+            SetEndDate(2013, 10, 11);
+            AddEquity("SPY", Resolution.Minute);
+        }
+
+        /// <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>
+        /// OnOrderEvent is called whenever an order is updated
+        /// </summary>
+        /// <param name="orderEvent">Order Event</param>
+        public override void OnOrderEvent(OrderEvent orderEvent)
+        {
+            throw new Exception("OnOrderEvent exception");
+        }
+
+        /// <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>
+        {
+        };
+    }
+}

Algorithm.CSharp/OptionAssignmentRegressionAlgorithm.cs

@@ -77,7 +77,7 @@ namespace QuantConnect.Algorithm.CSharp
 
         public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
-            {"Total Trades", "22"},
+            {"Total Trades", "24"},
             {"Average Win", "0%"},
             {"Average Loss", "0%"},
             {"Compounding Annual Return", "0%"},
@@ -101,8 +101,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
             {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "-50.218"},
-            {"Portfolio Turnover", "6.713"},
+            {"Return Over Maximum Drawdown", "-50.725"},
+            {"Portfolio Turnover", "8.14"},
             {"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", "-1597098916"}
+            {"OrderListHash", "-2017313615"}
         };
     }
 }

Algorithm.CSharp/OptionChainConsistencyRegressionAlgorithm.cs

@@ -160,7 +160,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "2037056244"}
+            {"OrderListHash", "1393663292"}
         };
     }
 }

Algorithm.CSharp/OptionChainSubscriptionRemovalRegressionAlgorithm.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.Linq;
+using QuantConnect.Interfaces;
+using QuantConnect.Securities;
+using System.Collections.Generic;
+using QuantConnect.Data.UniverseSelection;
+using QuantConnect.Algorithm.Framework.Selection;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Regression algorithm reproducing GH issue #3914 where the option chain subscriptions wouldn't get removed
+    /// </summary>
+    public class OptionChainSubscriptionRemovalRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private int _optionCount;
+        public override void Initialize()
+        {
+            UniverseSettings.Resolution = Resolution.Minute;
+            SetStartDate(2014, 06, 05);
+            SetEndDate(2014, 06, 09);
+
+            // this line is the key of this test it changed the behavior if the resolution used
+            // is < that Minute which is the Option resolution
+            AddEquity("SPY", Resolution.Second);
+            SetUniverseSelection(new TestOptionUniverseSelectionModel(SelectOptionChainSymbols));
+        }
+
+        public override void OnSecuritiesChanged(SecurityChanges changes)
+        {
+            _optionCount += changes.AddedSecurities.Count(security => security.Symbol.SecurityType == SecurityType.Option);
+
+            Log($"{GetStatusLog()} CHANGES: {changes}");
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            if (_optionCount != 30)
+            {
+                throw new Exception($"Unexpected option count {_optionCount}, expected 30");
+            }
+        }
+
+        private static IEnumerable<Symbol> SelectOptionChainSymbols(DateTime utcTime)
+        {
+            var newYorkTime = utcTime.ConvertFromUtc(TimeZones.NewYork);
+            if (newYorkTime.Date < new DateTime(2014, 06, 06))
+            {
+                yield return QuantConnect.Symbol.Create("TWX", SecurityType.Option, Market.USA, "?TWX");
+            }
+
+            if (newYorkTime.Date >= new DateTime(2014, 06, 06))
+            {
+                yield return QuantConnect.Symbol.Create("AAPL", SecurityType.Option, Market.USA, "?AAPL");
+            }
+        }
+
+        private string GetStatusLog()
+        {
+            Plot("Status", "UniverseCount", UniverseManager.Count);
+            Plot("Status", "SubscriptionCount", SubscriptionManager.Subscriptions.Count());
+            Plot("Status", "ActiveSymbolsCount", UniverseManager.ActiveSecurities.Count);
+
+            // why 50? we select 15 option contracts, which add trade/quote/openInterest = 45 + SPY & underlying trade/quote + universe subscription => 50
+            if (SubscriptionManager.Subscriptions.Count() > 50)
+            {
+                throw new Exception("Subscriptions aren't getting removed as expected!");
+            }
+
+            return $"{Time} | UniverseCount {UniverseManager.Count}. " +
+                $"SubscriptionCount {SubscriptionManager.Subscriptions.Count()}. " +
+                $"ActiveSymbols {string.Join(",", UniverseManager.ActiveSecurities.Keys)}";
+        }
+
+        class TestOptionUniverseSelectionModel : OptionUniverseSelectionModel
+        {
+            public TestOptionUniverseSelectionModel(Func<DateTime, IEnumerable<Symbol>> optionChainSymbolSelector)
+                : base(TimeSpan.FromDays(1), optionChainSymbolSelector)
+            {
+            }
+
+            protected override OptionFilterUniverse Filter(OptionFilterUniverse filter)
+            {
+                return filter.BackMonth().Contracts(filter.Take(15));
+            }
+        }
+
+        /// <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", "-25.506"},
+            {"Tracking Error", "0.042"},
+            {"Treynor Ratio", "0"},
+            {"Total Fees", "$0.00"},
+            {"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", "371857150"}
+        };
+    }
+}

Algorithm.CSharp/OptionChainUniverseRemovalRegressionAlgorithm.cs

@@ -0,0 +1,252 @@
+/*
+ * 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.UniverseSelection;
+using QuantConnect.Interfaces;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Regression algorithm which reproduces GH issue #5079, where option chain universes would sometimes not get removed from the
+    /// UniverseManager causing new universes not to get added
+    /// </summary>
+    public class OptionChainUniverseRemovalRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        // initialize our changes to nothing
+        private SecurityChanges _changes = SecurityChanges.None;
+        private int _optionCount;
+        private Symbol _lastEquityAdded;
+        private Symbol _aapl;
+
+        public override void Initialize()
+        {
+            _aapl = QuantConnect.Symbol.Create("AAPL", SecurityType.Equity, Market.USA);
+            UniverseSettings.Resolution = Resolution.Minute;
+
+            SetStartDate(2014, 06, 06);
+            SetEndDate(2014, 06, 10);
+
+            var toggle = true;
+            var selectionUniverse = AddUniverse(enumerable =>
+            {
+                if (toggle)
+                {
+                    toggle = false;
+                    return new []{ _aapl };
+                }
+                toggle = true;
+                return Enumerable.Empty<Symbol>();
+            });
+
+            AddUniverseOptions(selectionUniverse, universe =>
+            {
+                if (universe.Underlying == null)
+                {
+                    throw new Exception("Underlying data point is null! This shouldn't happen, each OptionChainUniverse handles and should provide this");
+                }
+                return universe.IncludeWeeklys()
+                    .BackMonth() // back month so that they don't get removed because of being delisted
+                    .Contracts(universe.Take(5));
+            });
+        }
+
+        public override void OnData(Slice data)
+        {
+            // if we have no changes, do nothing
+            if (_changes == SecurityChanges.None ||
+                _changes.AddedSecurities.Any(security => security.Price == 0))
+            {
+                return;
+            }
+
+            Debug(GetStatusLog());
+
+            foreach (var security in _changes.AddedSecurities)
+            {
+                if (!security.Symbol.HasUnderlying)
+                {
+                    _lastEquityAdded = security.Symbol;
+                }
+                else
+                {
+                    // options added should all match prev added security
+                    if (security.Symbol.Underlying != _lastEquityAdded)
+                    {
+                        throw new Exception($"Unexpected symbol added {security.Symbol}");
+                    }
+
+                    _optionCount++;
+                }
+            }
+            _changes = SecurityChanges.None;
+        }
+
+        public override void OnSecuritiesChanged(SecurityChanges changes)
+        {
+            Debug($"{GetStatusLog()}. CHANGES {changes}");
+            if (Time.Day == 6)
+            {
+                if (Time.Hour != 0 && Time.Hour != 9)
+                {
+                    throw new Exception($"Unexpected SecurityChanges time: {Time} {changes}");
+                }
+
+                if (changes.RemovedSecurities.Count != 0)
+                {
+                    throw new Exception($"Unexpected removals: {changes}");
+                }
+
+                if (Time.Hour == 0)
+                {
+                    // first we expect the equity to get Added
+                    if (changes.AddedSecurities.Count != 1 || changes.AddedSecurities[0].Symbol != _aapl)
+                    {
+                        throw new Exception($"Unexpected SecurityChanges: {changes}");
+                    }
+                }
+                else
+                {
+                    // later we expect the options to be Added
+                    if (changes.AddedSecurities.Count != 5 || changes.AddedSecurities.Any(security => security.Symbol.SecurityType != SecurityType.Option))
+                    {
+                        throw new Exception($"Unexpected SecurityChanges: {changes}");
+                    }
+                }
+            }
+            // We expect the equity to get Removed
+            else if (Time.Day == 7)
+            {
+                if (Time.Hour != 0)
+                {
+                    throw new Exception($"Unexpected SecurityChanges time: {Time} {changes}");
+                }
+
+                if (changes.AddedSecurities.Count != 0)
+                {
+                    throw new Exception($"Unexpected additions: {changes}");
+                }
+
+                if (changes.RemovedSecurities.Count != 1 || changes.RemovedSecurities[0].Symbol != _aapl)
+                {
+                    throw new Exception($"Unexpected SecurityChanges: {changes}");
+                }
+            }
+            // We expect the options to get Removed, happens in the next loop after removing the equity
+            else if (Time.Day == 9)
+            {
+                if (Time.Hour != 0)
+                {
+                    throw new Exception($"Unexpected SecurityChanges time: {Time} {changes}");
+                }
+
+                // later we expect the options to be Removed
+                if (changes.RemovedSecurities.Count != 6
+                    // the removal of the raw underlying subscription from the option chain universe
+                    || changes.RemovedSecurities.Single(security => security.Symbol.SecurityType != SecurityType.Option).Symbol != _aapl
+                    // the removal of the 5 option contracts
+                    || changes.RemovedSecurities.Count(security => security.Symbol.SecurityType == SecurityType.Option) != 5)
+                {
+                    throw new Exception($"Unexpected SecurityChanges: {changes}");
+                }
+            }
+
+            _changes += changes;
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            if (_optionCount == 0)
+            {
+                throw new Exception("Option universe chain did not add any option!");
+            }
+            if (UniverseManager.Any(pair => pair.Value.DisposeRequested))
+            {
+                throw new Exception("There shouldn't be any disposed universe, they should be removed and replaced by new universes");
+            }
+        }
+
+        private string GetStatusLog()
+        {
+            Plot("Status", "UniverseCount", UniverseManager.Count);
+            Plot("Status", "SubscriptionCount", SubscriptionManager.Subscriptions.Count());
+            Plot("Status", "ActiveSymbolsCount", UniverseManager.ActiveSecurities.Count);
+
+            return $"{Time} | UniverseCount {UniverseManager.Count}. " +
+                $"SubscriptionCount {SubscriptionManager.Subscriptions.Count()}. " +
+                $"ActiveSymbols {string.Join(",", UniverseManager.ActiveSecurities.Keys)}";
+        }
+
+        /// <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.31"},
+            {"Tracking Error", "0.008"},
+            {"Treynor Ratio", "0"},
+            {"Total Fees", "$0.00"},
+            {"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", "371857150"}
+        };
+    }
+}

Algorithm.CSharp/OptionExerciseAssignRegressionAlgorithm.cs

@@ -161,7 +161,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "-1726463684"}
+            {"OrderListHash", "-1004315474"}
         };
     }
 }

Algorithm.CSharp/OptionRenameRegressionAlgorithm.cs

@@ -40,14 +40,14 @@ namespace QuantConnect.Algorithm.CSharp
             SetEndDate(2013, 07, 02);
             SetCash(1000000);
 
-            var option = AddOption("FOXA");
+            var option = AddOption("TFCFA");
             _optionSymbol = option.Symbol;
 
             // set our strike/expiry filter for this option chain
             option.SetFilter(-1, +1, TimeSpan.Zero, TimeSpan.MaxValue);
 
             // use the underlying equity as the benchmark
-            SetBenchmark("FOXA");
+            SetBenchmark("TFCFA");
         }
 
         /// <summary>
@@ -56,6 +56,13 @@ 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 dividend in slice.Dividends.Values)
+            {
+                if (dividend.ReferencePrice != 32.59m || dividend.Distribution != 3.82m)
+                {
+                    throw new Exception($"{Time} - Invalid dividend {dividend}");
+                }
+            }
             if (!Portfolio.Invested)
             {
                 if (Time.Day == 28 && Time.Hour > 9 && Time.Minute > 0)
@@ -139,11 +146,11 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "4"},
             {"Average Win", "0%"},
             {"Average Loss", "-0.02%"},
-            {"Compounding Annual Return", "-0.453%"},
+            {"Compounding Annual Return", "-0.492%"},
             {"Drawdown", "0.000%"},
             {"Expectancy", "-1"},
             {"Net Profit", "-0.006%"},
-            {"Sharpe Ratio", "-3.554"},
+            {"Sharpe Ratio", "-3.943"},
             {"Probabilistic Sharpe Ratio", "0%"},
             {"Loss Rate", "100%"},
             {"Win Rate", "0%"},
@@ -152,15 +159,15 @@ namespace QuantConnect.Algorithm.CSharp
             {"Beta", "0"},
             {"Annual Standard Deviation", "0.002"},
             {"Annual Variance", "0"},
-            {"Information Ratio", "-3.554"},
+            {"Information Ratio", "-3.943"},
             {"Tracking Error", "0.002"},
             {"Treynor Ratio", "0"},
             {"Total Fees", "$4.00"},
-            {"Fitness Score", "0.001"},
+            {"Fitness Score", "0"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
             {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "-1.768"},
+            {"Return Over Maximum Drawdown", "-2.808"},
             {"Portfolio Turnover", "0.001"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
@@ -175,7 +182,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "-932374"}
+            {"OrderListHash", "-1383033718"}
         };
     }
 }

Algorithm.CSharp/QuantConnect.Algorithm.CSharp.csproj

@@ -1,95 +1,30 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <Import Project="..\packages\Microsoft.CodeAnalysis.FxCopAnalyzers.2.9.3\build\Microsoft.CodeAnalysis.FxCopAnalyzers.props" Condition="Exists('..\packages\Microsoft.CodeAnalysis.FxCopAnalyzers.2.9.3\build\Microsoft.CodeAnalysis.FxCopAnalyzers.props')" />
-  <Import Project="..\packages\Microsoft.NetFramework.Analyzers.2.9.3\build\Microsoft.NetFramework.Analyzers.props" Condition="Exists('..\packages\Microsoft.NetFramework.Analyzers.2.9.3\build\Microsoft.NetFramework.Analyzers.props')" />
-  <Import Project="..\packages\Microsoft.NetCore.Analyzers.2.9.3\build\Microsoft.NetCore.Analyzers.props" Condition="Exists('..\packages\Microsoft.NetCore.Analyzers.2.9.3\build\Microsoft.NetCore.Analyzers.props')" />
-  <Import Project="..\packages\Microsoft.CodeQuality.Analyzers.2.9.3\build\Microsoft.CodeQuality.Analyzers.props" Condition="Exists('..\packages\Microsoft.CodeQuality.Analyzers.2.9.3\build\Microsoft.CodeQuality.Analyzers.props')" />
-  <Import Project="..\packages\Microsoft.CodeAnalysis.VersionCheckAnalyzer.2.9.3\build\Microsoft.CodeAnalysis.VersionCheckAnalyzer.props" Condition="Exists('..\packages\Microsoft.CodeAnalysis.VersionCheckAnalyzer.2.9.3\build\Microsoft.CodeAnalysis.VersionCheckAnalyzer.props')" />
-  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+<Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectGuid>{39A81C16-A1E8-425E-A8F2-1433ADB80228}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
     <RootNamespace>QuantConnect.Algorithm.CSharp</RootNamespace>
     <AssemblyName>QuantConnect.Algorithm.CSharp</AssemblyName>
-    <TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
-    <FileAlignment>512</FileAlignment>
+    <TargetFramework>net462</TargetFramework>
     <LangVersion>6</LangVersion>
-    <TargetFrameworkProfile />
-    <NuGetPackageImportStamp>
-    </NuGetPackageImportStamp>
     <CodeAnalysisRuleSet>..\QuantConnect.ruleset</CodeAnalysisRuleSet>
+    <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
+    <OutputPath>bin\$(Configuration)\</OutputPath>
+    <CodeAnalysisRuleSet>..\QuantConnect.ruleset</CodeAnalysisRuleSet>
+    <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
+    <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
+    <GenerateBindingRedirectsOutputType>true</GenerateBindingRedirectsOutputType>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>bin\Debug\</OutputPath>
     <DebugType>full</DebugType>
     <Optimize>false</Optimize>
-    <OutputPath>bin\Debug\</OutputPath>
     <DefineConstants>DEBUG;TRACE</DefineConstants>
-    <ErrorReport>prompt</ErrorReport>
-    <WarningLevel>4</WarningLevel>
-    <LangVersion>6</LangVersion>
-    <CodeAnalysisRuleSet>..\QuantConnect.ruleset</CodeAnalysisRuleSet>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
     <DebugType>pdbonly</DebugType>
     <Optimize>true</Optimize>
-    <OutputPath>bin\Release\</OutputPath>
     <DefineConstants>TRACE</DefineConstants>
-    <ErrorReport>prompt</ErrorReport>
-    <WarningLevel>4</WarningLevel>
-    <LangVersion>6</LangVersion>
-    <CodeAnalysisRuleSet>..\QuantConnect.ruleset</CodeAnalysisRuleSet>
   </PropertyGroup>
-  <ItemGroup>
-    <Reference Include="Accord, Version=3.6.0.0, Culture=neutral, PublicKeyToken=fa1a88e29555ccf7, processorArchitecture=MSIL">
-      <HintPath>..\packages\Accord.3.6.0\lib\net462\Accord.dll</HintPath>
-    </Reference>
-    <Reference Include="Accord.Fuzzy, Version=3.6.0.0, Culture=neutral, PublicKeyToken=fa1a88e29555ccf7, processorArchitecture=MSIL">
-      <HintPath>..\packages\Accord.Fuzzy.3.6.0\lib\net462\Accord.Fuzzy.dll</HintPath>
-    </Reference>
-    <Reference Include="Accord.MachineLearning, Version=3.6.0.0, Culture=neutral, PublicKeyToken=fa1a88e29555ccf7, processorArchitecture=MSIL">
-      <HintPath>..\packages\Accord.MachineLearning.3.6.0\lib\net462\Accord.MachineLearning.dll</HintPath>
-    </Reference>
-    <Reference Include="Accord.Math, Version=3.6.0.0, Culture=neutral, PublicKeyToken=fa1a88e29555ccf7, processorArchitecture=MSIL">
-      <HintPath>..\packages\Accord.Math.3.6.0\lib\net462\Accord.Math.dll</HintPath>
-    </Reference>
-    <Reference Include="Accord.Math.Core, Version=3.6.0.0, Culture=neutral, PublicKeyToken=fa1a88e29555ccf7, processorArchitecture=MSIL">
-      <HintPath>..\packages\Accord.Math.3.6.0\lib\net462\Accord.Math.Core.dll</HintPath>
-    </Reference>
-    <Reference Include="Accord.Statistics, Version=3.6.0.0, Culture=neutral, PublicKeyToken=fa1a88e29555ccf7, processorArchitecture=MSIL">
-      <HintPath>..\packages\Accord.Statistics.3.6.0\lib\net462\Accord.Statistics.dll</HintPath>
-    </Reference>
-    <Reference Include="DynamicInterop, Version=0.7.4.0, Culture=neutral, processorArchitecture=MSIL">
-      <HintPath>..\packages\DynamicInterop.0.7.4\lib\net40\DynamicInterop.dll</HintPath>
-    </Reference>
-    <Reference Include="MathNet.Numerics, Version=3.19.0.0, Culture=neutral, processorArchitecture=MSIL">
-      <HintPath>..\packages\MathNet.Numerics.3.19.0\lib\net40\MathNet.Numerics.dll</HintPath>
-    </Reference>
-    <Reference Include="Newtonsoft.Json, Version=10.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
-      <HintPath>..\packages\Newtonsoft.Json.10.0.3\lib\net45\Newtonsoft.Json.dll</HintPath>
-    </Reference>
-    <Reference Include="NodaTime, Version=1.3.0.0, Culture=neutral, PublicKeyToken=4226afe0d9b296d1, processorArchitecture=MSIL">
-      <HintPath>..\packages\NodaTime.1.3.4\lib\net35-Client\NodaTime.dll</HintPath>
-    </Reference>
-    <Reference Include="RDotNet, Version=1.6.5.0, Culture=neutral, processorArchitecture=MSIL">
-      <HintPath>..\packages\R.NET.Community.1.6.5\lib\net40\RDotNet.dll</HintPath>
-    </Reference>
-    <Reference Include="RDotNet.NativeLibrary, Version=1.6.5.0, Culture=neutral, processorArchitecture=MSIL">
-      <HintPath>..\packages\R.NET.Community.1.6.5\lib\net40\RDotNet.NativeLibrary.dll</HintPath>
-    </Reference>
-    <Reference Include="System" />
-    <Reference Include="System.Core" />
-    <Reference Include="System.Drawing" />
-    <Reference Include="System.Numerics" />
-    <Reference Include="System.Xml.Linq" />
-    <Reference Include="System.Data.DataSetExtensions" />
-    <Reference Include="Microsoft.CSharp" />
-    <Reference Include="System.Data" />
-    <Reference Include="System.Xml" />
-  </ItemGroup>
   <PropertyGroup>
     <IsWindows>false</IsWindows>
     <IsWindows Condition="'$(OS)' == 'Windows_NT'">true</IsWindows>
@@ -99,14 +34,9 @@
     <IsLinux Condition="'$(IsWindows)' != 'true' AND '$(IsOSX)' != 'true' AND '$([System.Runtime.InteropServices.RuntimeInformation]::IsOSPlatform($([System.Runtime.InteropServices.OSPlatform]::Linux)))' == 'true'">true</IsLinux>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'DebugDocker|AnyCPU'">
-    <DebugSymbols>true</DebugSymbols>
     <OutputPath>bin\Debug\</OutputPath>
     <DefineConstants>DEBUG;TRACE</DefineConstants>
     <DebugType>portable</DebugType>
-    <PlatformTarget>AnyCPU</PlatformTarget>
-    <LangVersion>6</LangVersion>
-    <ErrorReport>prompt</ErrorReport>
-    <CodeAnalysisRuleSet>..\QuantConnect.ruleset</CodeAnalysisRuleSet>
   </PropertyGroup>
   <Target Name="PrintRID" BeforeTargets="Build">
     <Message Text="IsWindows $(IsWindows)" Importance="high" />
@@ -118,352 +48,58 @@
     <When Condition="$(IsWindows) AND '$(ForceLinuxBuild)' != 'true'">
       <ItemGroup>
         <Reference Include="Python.Runtime, Version=1.0.5.30, Culture=neutral, processorArchitecture=MSIL">
-          <HintPath>..\packages\QuantConnect.pythonnet.1.0.5.30\lib\win\Python.Runtime.dll</HintPath>
+          <HintPath>$(NuGetPackageRoot)\quantconnect.pythonnet\1.0.5.30\lib\win\Python.Runtime.dll</HintPath>
         </Reference>
       </ItemGroup>
     </When>
     <When Condition="$(IsLinux) OR '$(ForceLinuxBuild)' == 'true'">
       <ItemGroup>
         <Reference Include="Python.Runtime, Version=1.0.5.30, Culture=neutral, processorArchitecture=MSIL">
-          <HintPath>..\packages\QuantConnect.pythonnet.1.0.5.30\lib\linux\Python.Runtime.dll</HintPath>
+          <HintPath>$(NuGetPackageRoot)\quantconnect.pythonnet\1.0.5.30\lib\linux\Python.Runtime.dll</HintPath>
         </Reference>
       </ItemGroup>
     </When>
     <When Condition="$(IsOSX) AND '$(ForceLinuxBuild)' != 'true'">
       <ItemGroup>
         <Reference Include="Python.Runtime, Version=1.0.5.30, Culture=neutral, processorArchitecture=MSIL">
-          <HintPath>..\packages\QuantConnect.pythonnet.1.0.5.30\lib\osx\Python.Runtime.dll</HintPath>
+          <HintPath>$(NuGetPackageRoot)\quantconnect.pythonnet\1.0.5.30\lib\osx\Python.Runtime.dll</HintPath>
         </Reference>
       </ItemGroup>
     </When>
   </Choose>
   <ItemGroup>
-    <Compile Include="..\Common\Properties\SharedAssemblyInfo.cs">
-      <Link>Properties\SharedAssemblyInfo.cs</Link>
-    </Compile>
-    <Compile Include="AddAlphaModelAlgorithm.cs" />
-    <Compile Include="CustomBuyingPowerModelAlgorithm.cs" />
-    <Compile Include="AddOptionContractExpiresRegressionAlgorithm.cs" />
-    <Compile Include="ScaledFillForwardDataRegressionAlgorithm.cs" />
-    <Compile Include="DailyHistoryForDailyResolutionRegressionAlgorithm.cs" />
-    <Compile Include="DailyHistoryForMinuteResolutionRegressionAlgorithm.cs" />
-    <Compile Include="ExtendedMarketHoursHistoryRegressionAlgorithm.cs" />
-    <Compile Include="EquityTickQuoteAdjustedModeRegressionAlgorithm.cs" />
-    <Compile Include="AddOptionContractFromUniverseRegressionAlgorithm.cs" />
-    <Compile Include="CoarseFineOptionUniverseChainRegressionAlgorithm.cs" />
-    <Compile Include="OptionChainedAndUniverseSelectionRegressionAlgorithm.cs" />
-    <Compile Include="OptionAssignmentRegressionAlgorithm.cs" />
-    <Compile Include="SwitchDataModeRegressionAlgorithm.cs" />
-    <Compile Include="AddRemoveOptionUniverseRegressionAlgorithm.cs" />
-    <Compile Include="AddRemoveSecurityRegressionAlgorithm.cs" />
-    <Compile Include="AddRiskManagementAlgorithm.cs" />
-    <Compile Include="AddUniverseSelectionModelAlgorithm.cs" />
-    <Compile Include="AddUniverseSelectionModelCoarseAlgorithm.cs" />
-    <Compile Include="Alphas\GasAndCrudeOilEnergyCorrelationAlpha.cs" />
-    <Compile Include="Alphas\GreenblattMagicFormulaAlpha.cs" />
-    <Compile Include="Alphas\IntradayReversalCurrencyMarketsAlpha.cs" />
-    <Compile Include="Alphas\ShareClassMeanReversionAlpha.cs" />
-    <Compile Include="Alphas\SykesShortMicroCapAlpha.cs" />
-    <Compile Include="Alphas\GlobalEquityMeanReversionIBSAlpha.cs" />
-    <Compile Include="Alphas\MeanReversionLunchBreakAlpha.cs" />
-    <Compile Include="Alphas\RebalancingLeveragedETFAlpha.cs" />
-    <Compile Include="Alphas\TriangleExchangeRateArbitrageAlpha.cs" />
-    <Compile Include="Alphas\TripleLeveragedETFPairVolatilityDecayAlpha.cs" />
-    <Compile Include="Alphas\VixDualThrustAlpha.cs" />
-    <Compile Include="AltData\CachedAlternativeDataAlgorithm.cs" />
-    <Compile Include="AltData\BenzingaNewsAlgorithm.cs" />
-    <Compile Include="AltData\SECReport8KAlgorithm.cs" />
-    <Compile Include="AltData\SmartInsiderTransactionAlgorithm.cs" />
-    <Compile Include="AltData\USTreasuryYieldCurveRateAlgorithm.cs" />
-    <Compile Include="AltData\TradingEconomicsAlgorithm.cs" />
-    <Compile Include="AltData\TiingoNewsAlgorithm.cs" />
-    <Compile Include="AutomaticIndicatorWarmupDataTypeRegressionAlgorithm.cs" />
-    <Compile Include="AutomaticIndicatorWarmupRegressionAlgorithm.cs" />
-    <Compile Include="BacktestingBrokerageRegressionAlgorithm.cs" />
-    <Compile Include="ExtendedMarketTradingRegressionAlgorithm.cs" />
-    <Compile Include="CoarseTiingoNewsUniverseSelectionAlgorithm.cs" />
-    <Compile Include="DelistedFutureLiquidateRegressionAlgorithm.cs" />
-    <Compile Include="EmaCrossFuturesFrontMonthAlgorithm.cs" />
-    <Compile Include="OpenInterestFuturesRegressionAlgorithm.cs" />
-    <Compile Include="CustomPartialFillModelAlgorithm.cs" />
-    <Compile Include="EquityTradeAndQuotesRegressionAlgorithm.cs" />
-    <Compile Include="BasicTemplateConstituentUniverseAlgorithm.cs" />
-    <Compile Include="ConsolidateRegressionAlgorithm.cs" />
-    <Compile Include="DefaultResolutionRegressionAlgorithm.cs" />
-    <Compile Include="BasicPythonIntegrationTemplateAlgorithm.cs" />
-    <Compile Include="BasicSetAccountCurrencyAlgorithm.cs" />
-    <Compile Include="FineFundamentalFilteredUniverseRegressionAlgorithm.cs" />
-    <Compile Include="FutureSharingTickerRegressionAlgorithm.cs" />
-    <Compile Include="LongOnlyAlphaStreamAlgorithm.cs" />
-    <Compile Include="Benchmarks\SECReportBenchmarkAlgorithm.cs" />
-    <Compile Include="Benchmarks\SmartInsiderEventBenchmarkAlgorithm.cs" />
-    <Compile Include="CustomBenchmarkRegressionAlgorithm.cs" />
-    <Compile Include="CustomDataAddDataOnSecuritiesChangedRegressionAlgorithm.cs" />
-    <Compile Include="CustomDataAddDataCoarseSelectionRegressionAlgorithm.cs" />
-    <Compile Include="CustomDataAddDataRegressionAlgorithm.cs" />
-    <Compile Include="DynamicSecurityDataAlgorithm.cs" />
-    <Compile Include="ConfidenceWeightedFrameworkAlgorithm.cs" />
-    <Compile Include="AccumulativeInsightPortfolioRegressionAlgorithm.cs" />
-    <Compile Include="EqualWeightingPortfolioConstructionModelFutureRegressionAlgorithm.cs" />
-    <Compile Include="FreePortfolioValueRegressionAlgorithm.cs" />
-    <Compile Include="LeveragePrecedenceRegressionAlgorithm.cs" />
-    <Compile Include="LiquidETFUniverseFrameworkAlgorithm.cs" />
-    <Compile Include="MarginCallClosedMarketRegressionAlgorithm.cs" />
-    <Compile Include="MarginRemainingRegressionAlgorithm.cs" />
-    <Compile Include="NoMarginCallExpectedRegressionAlgorithm.cs" />
-    <Compile Include="ObjectStoreExampleAlgorithm.cs" />
-    <Compile Include="OrderImmutabilityRegressionAlgorithm.cs" />
-    <Compile Include="OrderSubmissionDataRegressionAlgorithm.cs" />
-    <Compile Include="RegisterIndicatorRegressionAlgorithm.cs" />
-    <Compile Include="ScheduledEventsOrderRegressionAlgorithm.cs" />
-    <Compile Include="SectorWeightingFrameworkAlgorithm.cs" />
-    <Compile Include="OnEndOfDayAddDataRegressionAlgorithm.cs" />
-    <Compile Include="PortfolioRebalanceOnCustomFuncRegressionAlgorithm.cs" />
-    <Compile Include="PortfolioRebalanceOnDateRulesRegressionAlgorithm.cs" />
-    <Compile Include="PortfolioRebalanceOnInsightChangesRegressionAlgorithm.cs" />
-    <Compile Include="PortfolioRebalanceOnSecurityChangesRegressionAlgorithm.cs" />
-    <Compile Include="ResolutionSwitchingAlgorithm.cs" />
-    <Compile Include="SetHoldingsFutureRegressionAlgorithm.cs" />
-    <Compile Include="StringToSymbolImplicitConversionRegressionAlgorithm.cs" />
-    <Compile Include="TimeRulesDefaultTimeZoneRegressionAlgorithm.cs" />
-    <Compile Include="SetHoldingsMultipleTargetsRegressionAlgorithm.cs" />
-    <Compile Include="SetHoldingsMarketOnOpenRegressionAlgorithm.cs" />
-    <Compile Include="SmartInsiderDataAlgorithm.cs" />
-    <Compile Include="BasicTemplateAlgorithm.cs" />
-    <Compile Include="Benchmarks\StatefulCoarseUniverseSelectionBenchmark.cs" />
-    <Compile Include="Benchmarks\StatelessCoarseUniverseSelectionBenchmark.cs" />
-    <Compile Include="CapmAlphaRankingFrameworkAlgorithm.cs" />
-    <Compile Include="CustomUniverseWithBenchmarkRegressionAlgorithm.cs" />
-    <Compile Include="CoarseSelectionTimeRegressionAlgorithm.cs" />
-    <Compile Include="CustomUniverseSelectionRegressionAlgorithm.cs" />
-    <Compile Include="OnEndOfDayRegressionAlgorithm.cs" />
-    <Compile Include="TrainingInitializeRegressionAlgorithm.cs" />
-    <Compile Include="TrainingExampleAlgorithm.cs" />
-    <Compile Include="UniverseSharingSubscriptionTradableRegressionAlgorithm.cs" />
-    <Compile Include="UniverseUnchangedRegressionAlgorithm.cs" />
-    <Compile Include="USTreasuryYieldCurveDataAlgorithm.cs" />
-    <Compile Include="SECReportDataAlgorithm.cs" />
-    <Compile Include="CustomDataUsingMapFileRegressionAlgorithm.cs" />
-    <Compile Include="ConstituentsUniverseDataGeneratorAlgorithm.cs" />
-    <Compile Include="ConstituentsUniverseRegressionAlgorithm.cs" />
-    <Compile Include="G10CurrencySelectionModelFrameworkAlgorithm.cs" />
-    <Compile Include="ExpiryHelperAlphaModelFrameworkAlgorithm.cs" />
-    <Compile Include="CfdTimeZonesRegressionAlgorithm.cs" />
-    <Compile Include="EmitInsightCryptoCashAccountType.cs" />
-    <Compile Include="EmitInsightsAlgorithm.cs" />
-    <Compile Include="EmitInsightNoAlphaModelAlgorithm.cs" />
-    <Compile Include="CoarseNoLookAheadBiasAlgorithm.cs" />
-    <Compile Include="ConvertToFrameworkAlgorithm.cs" />
-    <Compile Include="HistoryWithSymbolChangesRegressionAlgorithm.cs" />
-    <Compile Include="FeeModelNotUsingAccountCurrency.cs" />
-    <Compile Include="InsightWeightingFrameworkAlgorithm.cs" />
-    <Compile Include="MaximumPortfolioDrawdownFrameworkAlgorithm.cs" />
-    <Compile Include="CompositeRiskManagementModelFrameworkAlgorithm.cs" />
-    <Compile Include="ProcessSplitSymbolsRegressionAlgorithm.cs" />
-    <Compile Include="RawPricesUniverseRegressionAlgorithm.cs" />
-    <Compile Include="SetAccountCurrencyCashBuyingPowerModelRegressionAlgorithm.cs" />
-    <Compile Include="SetAccountCurrencySecurityMarginModelRegressionAlgorithm.cs" />
-    <Compile Include="SetCashOnDataRegressionAlgorithm.cs" />
-    <Compile Include="SmaCrossUniverseSelectionAlgorithm.cs" />
-    <Compile Include="StartingCapitalRegressionAlgorithm.cs" />
-    <Compile Include="StopLossOnOrderEventRegressionAlgorithm.cs" />
-    <Compile Include="TotalPortfolioValueRegressionAlgorithm.cs" />
-    <Compile Include="TradingEconomicsCalendarIndicatorAlgorithm.cs" />
-    <Compile Include="TrailingStopRiskFrameworkAlgorithm.cs" />
-    <Compile Include="BasicTemplateFuturesFrameworkAlgorithm.cs" />
-    <Compile Include="BasicTemplateOptionsFrameworkAlgorithm.cs" />
-    <Compile Include="BlackLittermanPortfolioOptimizationFrameworkAlgorithm.cs" />
-    <Compile Include="DailyResolutionSplitRegressionAlgorithm.cs" />
-    <Compile Include="MeanVarianceOptimizationFrameworkAlgorithm.cs" />
-    <Compile Include="TiingoPriceAlgorithm.cs" />
-    <Compile Include="OptionExpiryDateOnHolidayCase.cs" />
-    <Compile Include="OptionDataNullReferenceRegressionAlgorithm.cs" />
-    <Compile Include="CancelOpenOrdersRegressionAlgorithm.cs" />
-    <Compile Include="OptionDelistedDataRegressionAlgorithm.cs" />
-    <Compile Include="PearsonCorrelationPairsTradingAlphaModelFrameworkAlgorithm.cs" />
-    <Compile Include="RawPricesCoarseUniverseAlgorithm.cs" />
-    <Compile Include="CompositeAlphaModelFrameworkAlgorithm.cs" />
-    <Compile Include="SectorExposureRiskFrameworkAlgorithm.cs" />
-    <Compile Include="DuplicateSecurityWithBenchmarkRegressionAlgorithm.cs" />
-    <Compile Include="BasicTemplateCryptoAlgorithm.cs" />
-    <Compile Include="BasicTemplateCryptoFrameworkAlgorithm.cs" />
-    <Compile Include="BasicTemplateIntrinioEconomicData.cs" />
-    <Compile Include="BasicTemplateFrameworkAlgorithm.cs" />
-    <Compile Include="BasicTemplateLibrary.cs" />
-    <Compile Include="Benchmarks\EmptyMinute400EquityBenchmark.cs" />
-    <Compile Include="Benchmarks\BasicTemplateBenchmark.cs" />
-    <Compile Include="Benchmarks\EmptySingleSecuritySecondEquityBenchmark.cs" />
-    <Compile Include="CustomFrameworkModelsAlgorithm.cs" />
-    <Compile Include="EmaCrossUniverseSelectionFrameworkAlgorithm.cs" />
-    <Compile Include="FinancialAdvisorDemoAlgorithm.cs" />
-    <Compile Include="ForexInternalFeedOnDataHigherResolutionRegressionAlgorithm.cs" />
-    <Compile Include="ForexInternalFeedOnDataSameResolutionRegressionAlgorithm.cs" />
-    <Compile Include="RollingWindowAlgorithm.cs" />
-    <Compile Include="BasicTemplateDailyAlgorithm.cs" />
-    <Compile Include="CallingRFromCSharp.cs" />
-    <Compile Include="FuturesMomentumAlgorithm.cs" />
-    <Compile Include="BasicTemplateFuturesConsolidationAlgorithm.cs" />
-    <Compile Include="BasicTemplateFuturesHistoryAlgorithm.cs" />
-    <Compile Include="BasicTemplateMultiAssetAlgorithm.cs" />
-    <Compile Include="FilteredIdentityAlgorithm.cs" />
-    <Compile Include="OptionExerciseAssignRegressionAlgorithm.cs" />
-    <Compile Include="BasicTemplateOptionsFilterUniverseAlgorithm.cs" />
-    <Compile Include="BasicTemplateOptionsHistoryAlgorithm.cs" />
-    <Compile Include="BasicTemplateOptionTradesAlgorithm.cs" />
-    <Compile Include="OptionChainConsistencyRegressionAlgorithm.cs" />
-    <Compile Include="OptionOpenInterestRegressionAlgorithm.cs" />
-    <Compile Include="RegressionChannelAlgorithm.cs" />
-    <Compile Include="BasicTemplateFuturesAlgorithm.cs" />
-    <Compile Include="BasicTemplateOptionStrategyAlgorithm.cs" />
-    <Compile Include="CoarseFineFundamentalRegressionAlgorithm.cs" />
-    <Compile Include="CoarseFineFundamentalComboAlgorithm.cs" />
-    <Compile Include="FuzzyInferenceAlgorithm.cs" />
-    <Compile Include="OptionRenameRegressionAlgorithm.cs" />
-    <Compile Include="OptionSplitRegressionAlgorithm.cs" />
-    <Compile Include="PortfolioOptimizationNumericsAlgorithm.cs" />
-    <Compile Include="BasicTemplateForexAlgorithm.cs" />
-    <Compile Include="AccordVectorMachinesAlgorithm.cs" />
-    <Compile Include="BasicTemplateOptionsAlgorithm.cs" />
-    <Compile Include="CoarseFundamentalTop3Algorithm.cs" />
-    <Compile Include="CustomBenchmarkAlgorithm.cs" />
-    <Compile Include="CustomBrokerageMessageHandlerAlgorithm.cs" />
-    <Compile Include="FractionalQuantityRegressionAlgorithm.cs" />
-    <Compile Include="CustomDataRegressionAlgorithm.cs" />
-    <Compile Include="CustomDataUniverseAlgorithm.cs" />
-    <Compile Include="CustomModelsAlgorithm.cs" />
-    <Compile Include="CustomSecurityInitializerAlgorithm.cs">
-      <SubType>Code</SubType>
-    </Compile>
-    <Compile Include="DelistingEventsAlgorithm.cs" />
-    <Compile Include="DropboxBaseDataUniverseSelectionAlgorithm.cs" />
-    <Compile Include="HistoryAlgorithm.cs" />
-    <Compile Include="IndicatorWarmupAlgorithm.cs" />
-    <Compile Include="LimitFillRegressionAlgorithm.cs" />
-    <Compile Include="BasicTemplateFillForwardAlgorithm.cs" />
-    <Compile Include="BrokerageModelAlgorithm.cs" />
-    <Compile Include="BubbleAlgorithm.cs" />
-    <Compile Include="CustomChartingAlgorithm.cs" />
-    <Compile Include="CustomDataBitcoinAlgorithm.cs" />
-    <Compile Include="CustomDataNIFTYAlgorithm.cs" />
-    <Compile Include="DailyAlgorithm.cs" />
-    <Compile Include="DataConsolidationAlgorithm.cs" />
-    <Compile Include="DisplacedMovingAverageRibbon.cs" />
-    <Compile Include="DividendAlgorithm.cs" />
-    <Compile Include="ETFGlobalRotationAlgorithm.cs" />
-    <Compile Include="IndicatorSuiteAlgorithm.cs" />
-    <Compile Include="LiveFeaturesAlgorithm.cs" />
-    <Compile Include="OpeningBreakoutAlgorithm.cs" />
-    <Compile Include="DropboxUniverseSelectionAlgorithm.cs" />
-    <Compile Include="ParameterizedAlgorithm.cs" />
-    <Compile Include="HourReverseSplitRegressionAlgorithm.cs" />
-    <Compile Include="HourSplitRegressionAlgorithm.cs" />
-    <Compile Include="ScheduledUniverseSelectionModelRegressionAlgorithm.cs" />
-    <Compile Include="StandardDeviationExecutionModelRegressionAlgorithm.cs" />
-    <Compile Include="TimeInForceAlgorithm.cs" />
-    <Compile Include="UniverseSelectionDefinitionsAlgorithm.cs" />
-    <Compile Include="UniverseSharingSecurityDifferentSubscriptionRequestRegressionAlgorithm.cs" />
-    <Compile Include="UniverseSharingSubscriptionRequestRegressionAlgorithm.cs" />
-    <Compile Include="EstimizeDataAlgorithm.cs" />
-    <Compile Include="USEnergyInformationAdministrationAlgorithm.cs" />
-    <Compile Include="UserDefinedUniverseAlgorithm.cs" />
-    <Compile Include="VolumeWeightedAveragePriceExecutionModelRegressionAlgorithm.cs" />
-    <Compile Include="WarmupAlgorithm.cs" />
-    <Compile Include="WarmupConversionRatesRegressionAlgorithm.cs" />
-    <Compile Include="WarmupHistoryAlgorithm.cs" />
-    <Compile Include="MACDTrendAlgorithm.cs" />
-    <Compile Include="MarginCallEventsAlgorithm.cs" />
-    <Compile Include="MarketOnOpenOnCloseAlgorithm.cs" />
-    <Compile Include="MovingAverageCrossAlgorithm.cs" />
-    <Compile Include="MultipleSymbolConsolidationAlgorithm.cs" />
-    <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="QuandlFuturesDataAlgorithm.cs" />
-    <Compile Include="QuandlImporterAlgorithm.cs" />
-    <Compile Include="RegressionAlgorithm.cs" />
-    <Compile Include="RenkoConsolidatorAlgorithm.cs" />
-    <Compile Include="ScheduledEventsAlgorithm.cs" />
-    <Compile Include="ScheduledQueuingAlgorithm.cs" />
-    <Compile Include="StressSymbolsAlgorithm.cs" />
-    <Compile Include="StressSymbols.cs" />
-    <Compile Include="TickDataFilteringAlgorithm.cs" />
-    <Compile Include="EmaCrossUniverseSelectionAlgorithm.cs" />
-    <Compile Include="UniverseSelectionRegressionAlgorithm.cs" />
-    <Compile Include="UpdateOrderLiveTestAlgorithm.cs" />
-    <Compile Include="UpdateOrderRegressionAlgorithm.cs" />
-    <Compile Include="OrderTicketDemoAlgorithm.cs" />
-    <Compile Include="WarmupIndicatorRegressionAlgorithm.cs" />
-    <Compile Include="InceptionDateSelectionRegressionAlgorithm.cs" />
-    <Compile Include="WeeklyUniverseSelectionRegressionAlgorithm.cs" />
-    <Compile Include="OptionChainProviderAlgorithm.cs" />
-    <Compile Include="ConstituentsQC500GeneratorAlgorithm.cs" />
-    <Compile Include="CustomDataIndicatorExtensionsAlgorithm.cs" />
-    <Compile Include="Benchmarks\ScheduledEventsBenchmark.cs" />
-    <Compile Include="Benchmarks\HistoryRequestBenchmark.cs" />
-    <Compile Include="Benchmarks\CoarseFineUniverseSelectionBenchmark.cs" />
-    <Compile Include="Benchmarks\IndicatorRibbonBenchmark.cs" />
-    <Compile Include="ZeroFeeRegressionAlgorithm.cs" />
+    <PackageReference Include="Accord" Version="3.6.0" />
+    <PackageReference Include="Accord.Fuzzy" Version="3.6.0" />
+    <PackageReference Include="Accord.MachineLearning" Version="3.6.0" />
+    <PackageReference Include="Accord.Math" Version="3.6.0" />
+    <PackageReference Include="Accord.Statistics" Version="3.6.0" />
+    <PackageReference Include="DynamicInterop" Version="0.7.4" />
+    <PackageReference Include="MathNet.Numerics" Version="3.19.0" />
+    <PackageReference Include="Microsoft.CodeAnalysis.FxCopAnalyzers" Version="2.9.3" />
+    <PackageReference Include="Microsoft.CodeAnalysis.VersionCheckAnalyzer" Version="2.9.3" />
+    <PackageReference Include="Microsoft.CodeQuality.Analyzers" Version="2.9.3" />
+    <PackageReference Include="Microsoft.Net.Compilers" Version="2.10.0">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+    <PackageReference Include="Microsoft.NetCore.Analyzers" Version="2.9.3" />
+    <PackageReference Include="Microsoft.NetFramework.Analyzers" Version="2.9.3" />
+    <PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
+    <PackageReference Include="NodaTime" Version="3.0.5" />
+    <PackageReference Include="QuantConnect.pythonnet" Version="1.0.5.30" />
+    <PackageReference Include="R.NET.Community" Version="1.6.5" />
   </ItemGroup>
   <ItemGroup>
-    <ProjectReference Include="..\Algorithm.Framework\QuantConnect.Algorithm.Framework.csproj">
-      <Project>{75981418-7246-4b91-b136-482728e02901}</Project>
-      <Name>QuantConnect.Algorithm.Framework</Name>
-    </ProjectReference>
-    <ProjectReference Include="..\Algorithm\QuantConnect.Algorithm.csproj">
-      <Project>{3240aca4-bdd4-4d24-ac36-bbb651c39212}</Project>
-      <Name>QuantConnect.Algorithm</Name>
-    </ProjectReference>
-    <ProjectReference Include="..\Common\QuantConnect.csproj">
-      <Project>{2545c0b4-fabb-49c9-8dd1-9ad7ee23f86b}</Project>
-      <Name>QuantConnect</Name>
-    </ProjectReference>
-    <ProjectReference Include="..\Indicators\QuantConnect.Indicators.csproj">
-      <Project>{73fb2522-c3ed-4e47-8e3d-afad48a6b888}</Project>
-      <Name>QuantConnect.Indicators</Name>
-    </ProjectReference>
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
   </ItemGroup>
   <ItemGroup>
-    <None Include="app.config">
-      <SubType>Designer</SubType>
-    </None>
-    <None Include="packages.config">
-      <SubType>Designer</SubType>
-    </None>
+    <Compile Include="..\Common\Properties\SharedAssemblyInfo.cs" Link="Properties\SharedAssemblyInfo.cs" />
   </ItemGroup>
   <ItemGroup>
-    <WCFMetadata Include="Connected Services\" />
+    <ProjectReference Include="..\Algorithm.Framework\QuantConnect.Algorithm.Framework.csproj" />
+    <ProjectReference Include="..\Algorithm\QuantConnect.Algorithm.csproj" />
+    <ProjectReference Include="..\Common\QuantConnect.csproj" />
+    <ProjectReference Include="..\Indicators\QuantConnect.Indicators.csproj" />
   </ItemGroup>
-  <ItemGroup>
-    <Analyzer Include="..\packages\Microsoft.CodeAnalysis.VersionCheckAnalyzer.2.9.3\analyzers\dotnet\Microsoft.CodeAnalysis.VersionCheckAnalyzer.dll" />
-    <Analyzer Include="..\packages\Microsoft.CodeQuality.Analyzers.2.9.3\analyzers\dotnet\cs\Humanizer.dll" />
-    <Analyzer Include="..\packages\Microsoft.CodeQuality.Analyzers.2.9.3\analyzers\dotnet\cs\Microsoft.CodeQuality.Analyzers.dll" />
-    <Analyzer Include="..\packages\Microsoft.CodeQuality.Analyzers.2.9.3\analyzers\dotnet\cs\Microsoft.CodeQuality.CSharp.Analyzers.dll" />
-    <Analyzer Include="..\packages\Microsoft.NetCore.Analyzers.2.9.3\analyzers\dotnet\cs\Microsoft.NetCore.Analyzers.dll" />
-    <Analyzer Include="..\packages\Microsoft.NetCore.Analyzers.2.9.3\analyzers\dotnet\cs\Microsoft.NetCore.CSharp.Analyzers.dll" />
-    <Analyzer Include="..\packages\Microsoft.NetFramework.Analyzers.2.9.3\analyzers\dotnet\cs\Microsoft.NetFramework.Analyzers.dll" />
-    <Analyzer Include="..\packages\Microsoft.NetFramework.Analyzers.2.9.3\analyzers\dotnet\cs\Microsoft.NetFramework.CSharp.Analyzers.dll" />
-  </ItemGroup>
-  <ItemGroup>
-    <Compile Include="DaylightSavingTimeHistoryRegressionAlgorithm.cs" />
-  </ItemGroup>
-  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
-  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
-    <PropertyGroup>
-      <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
-    </PropertyGroup>
-    <Error Condition="!Exists('..\packages\QuantConnect.pythonnet.1.0.5.30\build\QuantConnect.pythonnet.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\QuantConnect.pythonnet.1.0.5.30\build\QuantConnect.pythonnet.targets'))" />
-    <Error Condition="!Exists('..\packages\Microsoft.CodeAnalysis.VersionCheckAnalyzer.2.9.3\build\Microsoft.CodeAnalysis.VersionCheckAnalyzer.props')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\Microsoft.CodeAnalysis.VersionCheckAnalyzer.2.9.3\build\Microsoft.CodeAnalysis.VersionCheckAnalyzer.props'))" />
-    <Error Condition="!Exists('..\packages\Microsoft.CodeQuality.Analyzers.2.9.3\build\Microsoft.CodeQuality.Analyzers.props')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\Microsoft.CodeQuality.Analyzers.2.9.3\build\Microsoft.CodeQuality.Analyzers.props'))" />
-    <Error Condition="!Exists('..\packages\Microsoft.NetCore.Analyzers.2.9.3\build\Microsoft.NetCore.Analyzers.props')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\Microsoft.NetCore.Analyzers.2.9.3\build\Microsoft.NetCore.Analyzers.props'))" />
-    <Error Condition="!Exists('..\packages\Microsoft.NetFramework.Analyzers.2.9.3\build\Microsoft.NetFramework.Analyzers.props')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\Microsoft.NetFramework.Analyzers.2.9.3\build\Microsoft.NetFramework.Analyzers.props'))" />
-    <Error Condition="!Exists('..\packages\Microsoft.CodeAnalysis.FxCopAnalyzers.2.9.3\build\Microsoft.CodeAnalysis.FxCopAnalyzers.props')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\Microsoft.CodeAnalysis.FxCopAnalyzers.2.9.3\build\Microsoft.CodeAnalysis.FxCopAnalyzers.props'))" />
-    <Error Condition="!Exists('..\packages\Accord.3.6.0\build\Accord.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\Accord.3.6.0\build\Accord.targets'))" />
-  </Target>
-  <Import Project="..\packages\QuantConnect.pythonnet.1.0.5.30\build\QuantConnect.pythonnet.targets" Condition="Exists('..\packages\QuantConnect.pythonnet.1.0.5.30\build\QuantConnect.pythonnet.targets')" />
-  <Import Project="..\packages\Accord.3.6.0\build\Accord.targets" Condition="Exists('..\packages\Accord.3.6.0\build\Accord.targets')" />
-  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
-       Other similar extension points exist, see Microsoft.Common.targets.
-  <Target Name="BeforeBuild">
-  </Target>
-  <Target Name="AfterBuild">
-  </Target>
-  -->
-</Project>
+</Project>

Algorithm.CSharp/SetAccountCurrencyCashBuyingPowerModelRegressionAlgorithm.cs

@@ -254,13 +254,13 @@ namespace QuantConnect.Algorithm.CSharp
             {"Information Ratio", "0"},
             {"Tracking Error", "0"},
             {"Treynor Ratio", "0"},
-            {"Total Fees", "$48.56"},
+            {"Total Fees", "$48.58"},
             {"Fitness Score", "0.5"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
             {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "-141.917"},
-            {"Portfolio Turnover", "2.001"},
+            {"Return Over Maximum Drawdown", "-141.877"},
+            {"Portfolio Turnover", "2.002"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
             {"Total Insights Analysis Completed", "0"},
@@ -274,7 +274,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "-22119963"}
+            {"OrderListHash", "-263077697"}
         };
     }
 }

Algorithm.CSharp/ShortableProviderOrdersRejectedRegressionAlgorithm.cs

@@ -0,0 +1,211 @@
+/*
+ * 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.Brokerages;
+using QuantConnect.Data;
+using QuantConnect.Data.Shortable;
+using QuantConnect.Interfaces;
+using QuantConnect.Orders;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Tests that orders are denied if they exceed the max shortable quantity.
+    /// </summary>
+    public class ShortableProviderOrdersRejectedRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Symbol _spy;
+        private Symbol _aig;
+        private readonly List<OrderTicket> _ordersAllowed = new List<OrderTicket>();
+        private readonly List<OrderTicket> _ordersDenied = new List<OrderTicket>();
+        private bool _initialize;
+        private bool _invalidatedAllowedOrder;
+        private bool _invalidatedNewOrderWithPortfolioHoldings;
+
+        public override void Initialize()
+        {
+            SetStartDate(2013, 10, 4);
+            SetEndDate(2013, 10, 11);
+            SetCash(10000000);
+
+            _spy = AddEquity("SPY", Resolution.Minute).Symbol;
+            _aig = AddEquity("AIG", Resolution.Minute).Symbol;
+
+            SetBrokerageModel(new RegressionTestShortableBrokerageModel());
+        }
+
+        public override void OnData(Slice data)
+        {
+            if (!_initialize)
+            {
+                HandleOrder(LimitOrder(_spy, -1001, 10000m)); // Should be canceled, exceeds the max shortable quantity
+                HandleOrder(LimitOrder(_spy, -1000, 10000m)); // Allowed, orders at or below 1000 should be accepted
+                HandleOrder(LimitOrder(_spy, -10, 0.01m)); // Should be canceled, the total quantity we would be short would exceed the max shortable quantity.
+                _initialize = true;
+                return;
+            }
+
+            if (!_invalidatedAllowedOrder)
+            {
+                if (_ordersAllowed.Count != 1)
+                {
+                    throw new Exception($"Expected 1 successful order, found: {_ordersAllowed.Count}");
+                }
+                if (_ordersDenied.Count != 2)
+                {
+                    throw new Exception($"Expected 2 failed orders, found: {_ordersDenied.Count}");
+                }
+
+                var allowedOrder = _ordersAllowed[0];
+                var orderUpdate = new UpdateOrderFields()
+                {
+                    LimitPrice = 0.01m,
+                    Quantity = -1001,
+                    Tag = "Testing updating and exceeding maximum quantity"
+                };
+
+                var response = allowedOrder.Update(orderUpdate);
+                if (response.ErrorCode != OrderResponseErrorCode.ExceedsShortableQuantity)
+                {
+                    throw new Exception($"Expected order to fail due to exceeded shortable quantity, found: {response.ErrorCode.ToString()}");
+                }
+
+                var cancelResponse = allowedOrder.Cancel();
+                if (cancelResponse.IsError)
+                {
+                    throw new Exception("Expected to be able to cancel open order after bad qty update");
+                }
+
+                _invalidatedAllowedOrder = true;
+                _ordersDenied.Clear();
+                _ordersAllowed.Clear();
+                return;
+            }
+
+            if (!_invalidatedNewOrderWithPortfolioHoldings)
+            {
+                HandleOrder(MarketOrder(_spy, -1000)); // Should succeed, no holdings and no open orders to stop this
+                var spyShares = Portfolio[_spy].Quantity;
+                if (spyShares != -1000m)
+                {
+                    throw new Exception($"Expected -1000 shares in portfolio, found: {spyShares}");
+                }
+
+                HandleOrder(LimitOrder(_spy, -1, 0.01m)); // Should fail, portfolio holdings are at the max shortable quantity.
+                if (_ordersDenied.Count != 1)
+                {
+                    throw new Exception($"Expected limit order to fail due to existing holdings, but found {_ordersDenied.Count} failures");
+                }
+
+                _ordersAllowed.Clear();
+                _ordersDenied.Clear();
+
+                HandleOrder(MarketOrder(_aig, -1001));
+                if (_ordersAllowed.Count != 1)
+                {
+                    throw new Exception($"Expected market order of -1001 BAC to not fail");
+                }
+
+                _invalidatedNewOrderWithPortfolioHoldings = true;
+            }
+        }
+
+        private void HandleOrder(OrderTicket orderTicket)
+        {
+            if (orderTicket.SubmitRequest.Status == OrderRequestStatus.Error)
+            {
+                _ordersDenied.Add(orderTicket);
+                return;
+            }
+
+            _ordersAllowed.Add(orderTicket);
+        }
+
+        private class RegressionTestShortableProvider : LocalDiskShortableProvider
+        {
+            public RegressionTestShortableProvider() : base(SecurityType.Equity, "testbrokerage", Market.USA)
+            {
+            }
+        }
+
+        public class RegressionTestShortableBrokerageModel : DefaultBrokerageModel
+        {
+            public RegressionTestShortableBrokerageModel() : base()
+            {
+                ShortableProvider = new RegressionTestShortableProvider();
+            }
+        }
+
+        /// <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%"},
+            {"Compounding Annual Return", "-1.719%"},
+            {"Drawdown", "0.100%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "-0.036%"},
+            {"Sharpe Ratio", "-1.741"},
+            {"Probabilistic Sharpe Ratio", "35.789%"},
+            {"Loss Rate", "0%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "0.004"},
+            {"Beta", "-0.023"},
+            {"Annual Standard Deviation", "0.005"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "-2.512"},
+            {"Tracking Error", "0.216"},
+            {"Treynor Ratio", "0.367"},
+            {"Total Fees", "$10.01"},
+            {"Fitness Score", "0"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "-4.849"},
+            {"Return Over Maximum Drawdown", "-21.738"},
+            {"Portfolio Turnover", "0.003"},
+            {"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", "1777297925"}
+        };
+    }
+}

Algorithm.CSharp/TotalPortfolioValueRegressionAlgorithm.cs

@@ -117,28 +117,28 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "3528"},
             {"Average Win", "0.67%"},
             {"Average Loss", "-0.71%"},
-            {"Compounding Annual Return", "17.318%"},
+            {"Compounding Annual Return", "17.227%"},
             {"Drawdown", "63.700%"},
             {"Expectancy", "0.020"},
-            {"Net Profit", "17.318%"},
-            {"Sharpe Ratio", "0.836"},
-            {"Probabilistic Sharpe Ratio", "33.715%"},
+            {"Net Profit", "17.227%"},
+            {"Sharpe Ratio", "0.834"},
+            {"Probabilistic Sharpe Ratio", "33.688%"},
             {"Loss Rate", "48%"},
             {"Win Rate", "52%"},
             {"Profit-Loss Ratio", "0.95"},
-            {"Alpha", "0.826"},
+            {"Alpha", "0.825"},
             {"Beta", "-0.34"},
             {"Annual Standard Deviation", "0.945"},
             {"Annual Variance", "0.893"},
-            {"Information Ratio", "0.714"},
+            {"Information Ratio", "0.713"},
             {"Tracking Error", "0.957"},
-            {"Treynor Ratio", "-2.325"},
-            {"Total Fees", "$24713.42"},
+            {"Treynor Ratio", "-2.323"},
+            {"Total Fees", "$24760.85"},
             {"Fitness Score", "0.54"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "0.24"},
-            {"Return Over Maximum Drawdown", "0.272"},
+            {"Sortino Ratio", "0.238"},
+            {"Return Over Maximum Drawdown", "0.27"},
             {"Portfolio Turnover", "7.204"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
@@ -153,7 +153,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "-1547947497"}
+            {"OrderListHash", "843493486"}
         };
     }
 }

Algorithm.CSharp/UniverseSelectionSymbolCacheRemovalRegressionTest.cs

@@ -0,0 +1,147 @@
+ 
+/*
+ * 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;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Regression algorithm reproducing github issue #5191 where the symbol was removed from the cache
+    /// even if a subscription is still present
+    /// </summary>
+    public class UniverseSelectionSymbolCacheRemovalRegressionTest : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private bool _optionWasRemoved;
+        private Symbol _optionContract;
+        private Symbol _equitySymbol;
+
+        /// <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(2014, 06, 05);
+            SetEndDate(2014, 06, 23);
+
+            AddEquity("AAPL", Resolution.Daily);
+            _equitySymbol = AddEquity("TWX", Resolution.Minute).Symbol;
+
+            var contracts = OptionChainProvider.GetOptionContractList(_equitySymbol, UtcTime).ToList();
+
+            var callOptionSymbol = contracts
+                .Where(c => c.ID.OptionRight == OptionRight.Call)
+                .OrderBy(c => c.ID.Date)
+                .First();
+            _optionContract = AddOptionContract(callOptionSymbol).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)
+        {
+            var symbol = SymbolCache.GetSymbol("TWX");
+            if (symbol == null)
+            {
+                throw new Exception("Unexpected removal of symbol from cache!");
+            }
+
+            foreach (var dataDelisting in data.Delistings.Where(pair => pair.Value.Type == DelistingType.Delisted))
+            {
+                if (dataDelisting.Key != _optionContract)
+                {
+                    throw new Exception("Unexpected delisting event!");
+                }
+                _optionWasRemoved = true;
+            }
+
+            if (!Portfolio.Invested)
+            {
+                SetHoldings("AAPL", 0.1);
+            }
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            if (!_optionWasRemoved)
+            {
+                throw new Exception("Option contract was not removed!");
+            }
+        }
+
+        /// <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", "-3.072%"},
+            {"Drawdown", "0.400%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "-0.162%"},
+            {"Sharpe Ratio", "-2.017"},
+            {"Probabilistic Sharpe Ratio", "23.009%"},
+            {"Loss Rate", "0%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "-0.024"},
+            {"Beta", "-0.007"},
+            {"Annual Standard Deviation", "0.012"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "-4.487"},
+            {"Tracking Error", "0.053"},
+            {"Treynor Ratio", "3.645"},
+            {"Total Fees", "$1.00"},
+            {"Fitness Score", "0"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "-3.347"},
+            {"Return Over Maximum Drawdown", "-8.314"},
+            {"Portfolio Turnover", "0.006"},
+            {"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", "112416549"}
+        };
+    }
+}

Algorithm.CSharp/UniverseSharingSubscriptionTradableRegressionAlgorithm.cs

@@ -32,6 +32,7 @@ namespace QuantConnect.Algorithm.CSharp
     {
         private Symbol _spy;
         private int _reselectedSpy = -1;
+        private DateTime lastDataTime = DateTime.MinValue;
 
         /// <summary>
         /// Initialise the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must initialized.
@@ -57,6 +58,13 @@ namespace QuantConnect.Algorithm.CSharp
         /// <param name="data">Slice object keyed by symbol containing the stock data</param>
         public override void OnData(Slice data)
         {
+            if (lastDataTime == data.Time)
+            {
+                throw new Exception("Duplicate time for current data and last data slice");
+            }
+
+            lastDataTime = data.Time;
+
             if (_reselectedSpy == 0)
             {
                 if (!Securities[_spy].IsTradable)
@@ -111,29 +119,29 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "1"},
             {"Average Win", "0%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "75.079%"},
-            {"Drawdown", "2.200%"},
+            {"Compounding Annual Return", "69.904%"},
+            {"Drawdown", "2.000%"},
             {"Expectancy", "0"},
-            {"Net Profit", "4.711%"},
-            {"Sharpe Ratio", "5.067"},
-            {"Probabilistic Sharpe Ratio", "84.391%"},
+            {"Net Profit", "4.453%"},
+            {"Sharpe Ratio", "4.805"},
+            {"Probabilistic Sharpe Ratio", "83.459%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "0.562"},
-            {"Beta", "0.02"},
-            {"Annual Standard Deviation", "0.113"},
-            {"Annual Variance", "0.013"},
-            {"Information Ratio", "0.511"},
-            {"Tracking Error", "0.159"},
-            {"Treynor Ratio", "28.945"},
-            {"Total Fees", "$3.22"},
-            {"Fitness Score", "0.037"},
+            {"Alpha", "0.501"},
+            {"Beta", "0.068"},
+            {"Annual Standard Deviation", "0.111"},
+            {"Annual Variance", "0.012"},
+            {"Information Ratio", "0.284"},
+            {"Tracking Error", "0.153"},
+            {"Treynor Ratio", "7.844"},
+            {"Total Fees", "$3.23"},
+            {"Fitness Score", "0.038"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "17.868"},
-            {"Return Over Maximum Drawdown", "34.832"},
-            {"Portfolio Turnover", "0.037"},
+            {"Sortino Ratio", "16.857"},
+            {"Return Over Maximum Drawdown", "34.897"},
+            {"Portfolio Turnover", "0.038"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
             {"Total Insights Analysis Completed", "0"},
@@ -147,7 +155,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "836605283"}
+            {"OrderListHash", "1664042885"}
         };
     }
 }

Algorithm.CSharp/WarmUpAfterInitializeRegression.cs

@@ -0,0 +1,61 @@
+/*
+ * 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.Interfaces;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Regression algorithm to test warming up after initialize behavior, should throw if used outside of initialize
+    /// Reference GH Issue #4939
+    /// </summary>
+    public class WarmUpAfterInitializeRegression : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        public override void Initialize()
+        {
+            SetStartDate(2013, 10, 07);  //Set Start Date
+            SetEndDate(2013, 10, 11);    //Set End Date
+            SetCash(100000);
+            var equity = AddEquity("SPY");
+        }
+
+        public override void OnData(Slice slice)
+        {
+            // Should throw and set Algorithm status to be runtime error
+            SetWarmUp(TimeSpan.FromDays(2));
+        }
+
+        /// <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>
+        {
+        };
+    }
+}

Algorithm.CSharp/WarmupConversionRatesRegressionAlgorithm.cs

@@ -105,8 +105,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
             {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "-315.532"},
-            {"Portfolio Turnover", "0.998"},
+            {"Return Over Maximum Drawdown", "-315.48"},
+            {"Portfolio Turnover", "0.999"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
             {"Total Insights Analysis Completed", "0"},
@@ -120,7 +120,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "1318619937"}
+            {"OrderListHash", "1703396395"}
         };
     }
 }

Algorithm.CSharp/ZeroedBenchmarkRegressionAlgorithm.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.Collections.Generic;
+using QuantConnect.Benchmarks;
+using QuantConnect.Brokerages;
+using QuantConnect.Data;
+using QuantConnect.Interfaces;
+using QuantConnect.Securities;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Regression algorithm to test zeroed benchmark through BrokerageModel override
+    /// </summary>
+    public class ZeroedBenchmarkRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Symbol _spy;
+
+        /// <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, 08);    //Set End Date
+            SetCash(100000);             //Set Strategy Cash
+
+            // Add equity
+            _spy = AddEquity("SPY", Resolution.Hour).Symbol;
+
+            // Use our Test Brokerage Model with zeroed default benchmark
+            SetBrokerageModel(new TestBrokerageModel());
+        }
+
+        /// <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, 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", "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"},
+            {"Total Fees", "$3.25"},
+            {"Fitness Score", "0.498"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "79228162514264337593543950335"},
+            {"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", "-1491193070"}
+        };
+
+        internal class TestBrokerageModel : DefaultBrokerageModel
+        {
+            public override IBenchmark GetBenchmark(SecurityManager securities)
+            {
+                return new FuncBenchmark(x => 0);
+            }
+        }
+    }
+}

Algorithm.CSharp/app.config

@@ -1,11 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<configuration>
-  <runtime>
-    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
-      <dependentAssembly>
-        <assemblyIdentity name="Accord" publicKeyToken="fa1a88e29555ccf7" culture="neutral"/>
-        <bindingRedirect oldVersion="0.0.0.0-3.3.0.0" newVersion="3.3.0.0"/>
-      </dependentAssembly>
-    </assemblyBinding>
-  </runtime>
-<startup><supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.6.2"/></startup></configuration>

Algorithm.CSharp/packages.config

@@ -1,19 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="Accord" version="3.6.0" targetFramework="net462" />
-  <package id="Accord.Fuzzy" version="3.6.0" targetFramework="net462" />
-  <package id="Accord.MachineLearning" version="3.6.0" targetFramework="net462" />
-  <package id="Accord.Math" version="3.6.0" targetFramework="net462" />
-  <package id="Accord.Statistics" version="3.6.0" targetFramework="net462" />
-  <package id="DynamicInterop" version="0.7.4" targetFramework="net452" />
-  <package id="MathNet.Numerics" version="3.19.0" targetFramework="net452" />
-  <package id="Microsoft.CodeAnalysis.FxCopAnalyzers" version="2.9.3" targetFramework="net452" />
-  <package id="Microsoft.CodeAnalysis.VersionCheckAnalyzer" version="2.9.3" targetFramework="net452" />
-  <package id="Microsoft.CodeQuality.Analyzers" version="2.9.3" targetFramework="net452" />
-  <package id="Microsoft.NetCore.Analyzers" version="2.9.3" targetFramework="net452" />
-  <package id="Microsoft.NetFramework.Analyzers" version="2.9.3" targetFramework="net452" />
-  <package id="Newtonsoft.Json" version="10.0.3" targetFramework="net452" />
-  <package id="NodaTime" version="1.3.4" targetFramework="net452" />
-  <package id="QuantConnect.pythonnet" version="1.0.5.30" targetFramework="net452" />
-  <package id="R.NET.Community" version="1.6.5" targetFramework="net452" />
-</packages>

Algorithm.FSharp/BasicTemplateAlgorithm.fs

@@ -1,47 +0,0 @@
-// QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
-// Lean Algorithmic Trading Engine v2.0. Copyright 2015 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.
-
-namespace System
-namespace System.Collections.Generic
-namespace QuantConnnect
-namespace QuantConnect.Orders
-namespace QuantConnect.Algorithm
-namespace QuantConnect.Securities
-namespace QuantConnect.Algorithm.FSharp
-
-open System
-open QuantConnect
-open QuantConnect.Data.Market
-open QuantConnect.Algorithm
-
-
-// Declare algorithm name
-type BasicTemplateAlgorithm() =
-
-    //Reuse all the base class of QCAlgorithm
-    inherit QCAlgorithm()
-
-        //Implement core methods:
-        override this.Initialize() =
-            this.SetCash(100000)
-            this.SetStartDate(2013, 10, 07)
-            this.SetEndDate(2013, 10, 11)
-            this.AddSecurity(SecurityType.Equity, "SPY", Nullable Resolution.Second) |> ignore
-
-        //TradeBars Data Event
-        member this.OnData(bar:TradeBars) =
-
-            if not this.Portfolio.Invested then
-                this.SetHoldings(this.Symbol("SPY"), 1);
-            else
-                ()

Algorithm.FSharp/QuantConnect.Algorithm.FSharp.fsproj

@@ -1,149 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <Import Project="..\packages\Microsoft.CodeAnalysis.FxCopAnalyzers.2.9.3\build\Microsoft.CodeAnalysis.FxCopAnalyzers.props" Condition="Exists('..\packages\Microsoft.CodeAnalysis.FxCopAnalyzers.2.9.3\build\Microsoft.CodeAnalysis.FxCopAnalyzers.props')" />
-  <Import Project="..\packages\Microsoft.NetFramework.Analyzers.2.9.3\build\Microsoft.NetFramework.Analyzers.props" Condition="Exists('..\packages\Microsoft.NetFramework.Analyzers.2.9.3\build\Microsoft.NetFramework.Analyzers.props')" />
-  <Import Project="..\packages\Microsoft.NetCore.Analyzers.2.9.3\build\Microsoft.NetCore.Analyzers.props" Condition="Exists('..\packages\Microsoft.NetCore.Analyzers.2.9.3\build\Microsoft.NetCore.Analyzers.props')" />
-  <Import Project="..\packages\Microsoft.CodeQuality.Analyzers.2.9.3\build\Microsoft.CodeQuality.Analyzers.props" Condition="Exists('..\packages\Microsoft.CodeQuality.Analyzers.2.9.3\build\Microsoft.CodeQuality.Analyzers.props')" />
-  <Import Project="..\packages\Microsoft.CodeAnalysis.VersionCheckAnalyzer.2.9.3\build\Microsoft.CodeAnalysis.VersionCheckAnalyzer.props" Condition="Exists('..\packages\Microsoft.CodeAnalysis.VersionCheckAnalyzer.2.9.3\build\Microsoft.CodeAnalysis.VersionCheckAnalyzer.props')" />
-  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>7702711a-0c09-40d4-b151-e308d1520738</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <RootNamespace>QuantConnect.Algorithm.FSharp</RootNamespace>
-    <AssemblyName>QuantConnect.Algorithm.FSharp</AssemblyName>
-    <TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
-    <TargetFSharpCoreVersion>4.3.1.0</TargetFSharpCoreVersion>
-    <Name>QuantConnect.Algorithm.FSharp</Name>
-    <NuGetPackageImportStamp>
-    </NuGetPackageImportStamp>
-    <TargetFrameworkProfile />
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-    <DebugSymbols>true</DebugSymbols>
-    <DebugType>full</DebugType>
-    <Optimize>false</Optimize>
-    <Tailcalls>false</Tailcalls>
-    <OutputPath>bin\Debug\</OutputPath>
-    <DefineConstants>DEBUG;TRACE</DefineConstants>
-    <WarningLevel>3</WarningLevel>
-    <DocumentationFile>bin\Debug\QuantConnect.Algorithm.FSharp.xml</DocumentationFile>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-    <DebugType>pdbonly</DebugType>
-    <Optimize>true</Optimize>
-    <Tailcalls>true</Tailcalls>
-    <OutputPath>bin\Release\</OutputPath>
-    <DefineConstants>TRACE</DefineConstants>
-    <WarningLevel>3</WarningLevel>
-    <DocumentationFile>bin\Release\QuantConnect.Algorithm.FSharp.XML</DocumentationFile>
-  </PropertyGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib" />
-    <Reference Include="FSharp.Core, Version=$(TargetFSharpCoreVersion), Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
-      <Private>True</Private>
-    </Reference>
-    <Reference Include="NodaTime">
-      <HintPath>..\packages\NodaTime.1.3.4\lib\net35-Client\NodaTime.dll</HintPath>
-    </Reference>
-    <Reference Include="System" />
-    <Reference Include="System.Core" />
-    <Reference Include="System.Numerics" />
-    <Reference Include="System.Xml" />
-  </ItemGroup>
-  <PropertyGroup>
-    <IsWindows>false</IsWindows>
-    <IsWindows Condition="'$(OS)' == 'Windows_NT'">true</IsWindows>
-    <IsOSX>false</IsOSX>
-    <IsOSX Condition="'$(IsWindows)' != 'true' AND '$([System.Runtime.InteropServices.RuntimeInformation]::IsOSPlatform($([System.Runtime.InteropServices.OSPlatform]::OSX)))' == 'true'">true</IsOSX>
-    <IsLinux>false</IsLinux>
-    <IsLinux Condition="'$(IsWindows)' != 'true' AND '$(IsOSX)' != 'true' AND '$([System.Runtime.InteropServices.RuntimeInformation]::IsOSPlatform($([System.Runtime.InteropServices.OSPlatform]::Linux)))' == 'true'">true</IsLinux>
-  </PropertyGroup>
-  <Target Name="PrintRID" BeforeTargets="Build">
-    <Message Text="IsWindows $(IsWindows)" Importance="high" />
-    <Message Text="IsOSX $(IsOSX)" Importance="high" />
-    <Message Text="IsLinux $(IsLinux)" Importance="high" />
-    <Message Text="ForceLinuxBuild $(ForceLinuxBuild)" Importance="high" />
-  </Target>
-  <Choose>
-    <When Condition="$(IsWindows) AND '$(ForceLinuxBuild)' != 'true'">
-      <ItemGroup>
-        <Reference Include="Python.Runtime, Version=1.0.5.30, Culture=neutral, processorArchitecture=MSIL">
-          <HintPath>..\packages\QuantConnect.pythonnet.1.0.5.30\lib\win\Python.Runtime.dll</HintPath>
-        </Reference>
-      </ItemGroup>
-    </When>
-    <When Condition="$(IsLinux) OR '$(ForceLinuxBuild)' == 'true'">
-      <ItemGroup>
-        <Reference Include="Python.Runtime, Version=1.0.5.30, Culture=neutral, processorArchitecture=MSIL">
-          <HintPath>..\packages\QuantConnect.pythonnet.1.0.5.30\lib\linux\Python.Runtime.dll</HintPath>
-        </Reference>
-      </ItemGroup>
-    </When>
-    <When Condition="$(IsOSX) AND '$(ForceLinuxBuild)' != 'true'">
-      <ItemGroup>
-        <Reference Include="Python.Runtime, Version=1.0.5.30, Culture=neutral, processorArchitecture=MSIL">
-          <HintPath>..\packages\QuantConnect.pythonnet.1.0.5.30\lib\osx\Python.Runtime.dll</HintPath>
-        </Reference>
-      </ItemGroup>
-    </When>
-  </Choose>
-  <ItemGroup>
-    <Compile Include="BasicTemplateAlgorithm.fs" />
-    <None Include="packages.config" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="..\Algorithm\QuantConnect.Algorithm.csproj">
-      <Name>QuantConnect.Algorithm</Name>
-      <Project>{3240aca4-bdd4-4d24-ac36-bbb651c39212}</Project>
-      <Private>True</Private>
-    </ProjectReference>
-    <ProjectReference Include="..\Common\QuantConnect.csproj">
-      <Name>QuantConnect</Name>
-      <Project>{2545c0b4-fabb-49c9-8dd1-9ad7ee23f86b}</Project>
-      <Private>True</Private>
-    </ProjectReference>
-    <ProjectReference Include="..\Indicators\QuantConnect.Indicators.csproj">
-      <Name>QuantConnect.Indicators</Name>
-      <Project>{73fb2522-c3ed-4e47-8e3d-afad48a6b888}</Project>
-      <Private>True</Private>
-    </ProjectReference>
-  </ItemGroup>
-  <PropertyGroup>
-    <MinimumVisualStudioVersion Condition="'$(MinimumVisualStudioVersion)' == ''">11</MinimumVisualStudioVersion>
-  </PropertyGroup>
-  <Choose>
-    <When Condition="'$(VisualStudioVersion)' == '11.0'">
-      <PropertyGroup Condition="Exists('$(MSBuildExtensionsPath32)\..\Microsoft SDKs\F#\3.0\Framework\v4.0\Microsoft.FSharp.Targets')">
-        <FSharpTargetsPath>$(MSBuildExtensionsPath32)\..\Microsoft SDKs\F#\3.0\Framework\v4.0\Microsoft.FSharp.Targets</FSharpTargetsPath>
-      </PropertyGroup>
-    </When>
-    <Otherwise>
-      <PropertyGroup Condition="Exists('$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)\FSharp\Microsoft.FSharp.Targets')">
-        <FSharpTargetsPath>$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)\FSharp\Microsoft.FSharp.Targets</FSharpTargetsPath>
-      </PropertyGroup>
-    </Otherwise>
-  </Choose>
-  <Import Project="$(FSharpTargetsPath)" />
-  <Import Project="..\packages\QuantConnect.pythonnet.1.0.5.30\build\QuantConnect.pythonnet.targets" Condition="Exists('..\packages\QuantConnect.pythonnet.1.0.5.30\build\QuantConnect.pythonnet.targets')" />
-  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
-    <PropertyGroup>
-      <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
-    </PropertyGroup>
-    <Error Condition="!Exists('..\packages\QuantConnect.pythonnet.1.0.5.30\build\QuantConnect.pythonnet.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\QuantConnect.pythonnet.1.0.5.30\build\QuantConnect.pythonnet.targets'))" />
-    <Error Condition="!Exists('..\packages\Microsoft.CodeAnalysis.VersionCheckAnalyzer.2.9.3\build\Microsoft.CodeAnalysis.VersionCheckAnalyzer.props')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\Microsoft.CodeAnalysis.VersionCheckAnalyzer.2.9.3\build\Microsoft.CodeAnalysis.VersionCheckAnalyzer.props'))" />
-    <Error Condition="!Exists('..\packages\Microsoft.CodeQuality.Analyzers.2.9.3\build\Microsoft.CodeQuality.Analyzers.props')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\Microsoft.CodeQuality.Analyzers.2.9.3\build\Microsoft.CodeQuality.Analyzers.props'))" />
-    <Error Condition="!Exists('..\packages\Microsoft.NetCore.Analyzers.2.9.3\build\Microsoft.NetCore.Analyzers.props')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\Microsoft.NetCore.Analyzers.2.9.3\build\Microsoft.NetCore.Analyzers.props'))" />
-    <Error Condition="!Exists('..\packages\Microsoft.NetFramework.Analyzers.2.9.3\build\Microsoft.NetFramework.Analyzers.props')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\Microsoft.NetFramework.Analyzers.2.9.3\build\Microsoft.NetFramework.Analyzers.props'))" />
-    <Error Condition="!Exists('..\packages\Microsoft.CodeAnalysis.FxCopAnalyzers.2.9.3\build\Microsoft.CodeAnalysis.FxCopAnalyzers.props')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\Microsoft.CodeAnalysis.FxCopAnalyzers.2.9.3\build\Microsoft.CodeAnalysis.FxCopAnalyzers.props'))" />
-  </Target>
-  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
-       Other similar extension points exist, see Microsoft.Common.targets.
-  <Target Name="BeforeBuild">
-  </Target>
-  <Target Name="AfterBuild">
-  </Target>
-  -->
-</Project>

Algorithm.FSharp/packages.config

@@ -1,10 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="Microsoft.CodeAnalysis.FxCopAnalyzers" version="2.9.3" targetFramework="net452" />
-  <package id="Microsoft.CodeAnalysis.VersionCheckAnalyzer" version="2.9.3" targetFramework="net452" />
-  <package id="Microsoft.CodeQuality.Analyzers" version="2.9.3" targetFramework="net452" />
-  <package id="Microsoft.NetCore.Analyzers" version="2.9.3" targetFramework="net452" />
-  <package id="Microsoft.NetFramework.Analyzers" version="2.9.3" targetFramework="net452" />
-  <package id="NodaTime" version="1.3.4" targetFramework="net452" />
-  <package id="QuantConnect.pythonnet" version="1.0.5.30" targetFramework="net452" />
-</packages>

Algorithm.Framework/QuantConnect.Algorithm.Framework.csproj

@@ -1,76 +1,32 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <Import Project="..\packages\Microsoft.CodeAnalysis.FxCopAnalyzers.2.9.3\build\Microsoft.CodeAnalysis.FxCopAnalyzers.props" Condition="Exists('..\packages\Microsoft.CodeAnalysis.FxCopAnalyzers.2.9.3\build\Microsoft.CodeAnalysis.FxCopAnalyzers.props')" />
-  <Import Project="..\packages\Microsoft.NetFramework.Analyzers.2.9.3\build\Microsoft.NetFramework.Analyzers.props" Condition="Exists('..\packages\Microsoft.NetFramework.Analyzers.2.9.3\build\Microsoft.NetFramework.Analyzers.props')" />
-  <Import Project="..\packages\Microsoft.NetCore.Analyzers.2.9.3\build\Microsoft.NetCore.Analyzers.props" Condition="Exists('..\packages\Microsoft.NetCore.Analyzers.2.9.3\build\Microsoft.NetCore.Analyzers.props')" />
-  <Import Project="..\packages\Microsoft.CodeQuality.Analyzers.2.9.3\build\Microsoft.CodeQuality.Analyzers.props" Condition="Exists('..\packages\Microsoft.CodeQuality.Analyzers.2.9.3\build\Microsoft.CodeQuality.Analyzers.props')" />
-  <Import Project="..\packages\Microsoft.CodeAnalysis.VersionCheckAnalyzer.2.9.3\build\Microsoft.CodeAnalysis.VersionCheckAnalyzer.props" Condition="Exists('..\packages\Microsoft.CodeAnalysis.VersionCheckAnalyzer.2.9.3\build\Microsoft.CodeAnalysis.VersionCheckAnalyzer.props')" />
-  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+<Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectGuid>{75981418-7246-4B91-B136-482728E02901}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
     <RootNamespace>QuantConnect.Algorithm.Framework</RootNamespace>
     <AssemblyName>QuantConnect.Algorithm.Framework</AssemblyName>
-    <TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
-    <FileAlignment>512</FileAlignment>
-    <NuGetPackageImportStamp>
-    </NuGetPackageImportStamp>
-    <TargetFrameworkProfile />
+    <TargetFramework>net462</TargetFramework>
     <CodeAnalysisRuleSet>..\QuantConnect.ruleset</CodeAnalysisRuleSet>
+    <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
+    <OutputPath>bin\$(Configuration)\</OutputPath>
+    <DocumentationFile>bin\$(Configuration)\QuantConnect.Algorithm.Framework.xml</DocumentationFile>
+    <CodeAnalysisRuleSet>..\QuantConnect.ruleset</CodeAnalysisRuleSet>
+    <PackageTags>Library</PackageTags>
+    <LangVersion>6</LangVersion>
+    <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
+    <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
+    <AutoGenerateBindingRedirects>false</AutoGenerateBindingRedirects>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>bin\Debug\</OutputPath>
     <DebugType>full</DebugType>
     <Optimize>false</Optimize>
-    <OutputPath>bin\Debug\</OutputPath>
     <DefineConstants>DEBUG;TRACE</DefineConstants>
-    <ErrorReport>prompt</ErrorReport>
-    <WarningLevel>4</WarningLevel>
-    <LangVersion>6</LangVersion>
-    <DocumentationFile>bin\Debug\QuantConnect.Algorithm.Framework.xml</DocumentationFile>
-    <CodeAnalysisRuleSet>..\QuantConnect.ruleset</CodeAnalysisRuleSet>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
     <DebugType>pdbonly</DebugType>
     <Optimize>true</Optimize>
-    <OutputPath>bin\Release\</OutputPath>
     <DefineConstants>TRACE</DefineConstants>
-    <ErrorReport>prompt</ErrorReport>
-    <WarningLevel>4</WarningLevel>
-    <DocumentationFile>bin\Release\QuantConnect.Algorithm.Framework.xml</DocumentationFile>
-    <CodeAnalysisRuleSet>..\QuantConnect.ruleset</CodeAnalysisRuleSet>
   </PropertyGroup>
-  <ItemGroup>
-    <Reference Include="Accord, Version=3.6.0.0, Culture=neutral, PublicKeyToken=fa1a88e29555ccf7, processorArchitecture=MSIL">
-      <HintPath>..\packages\Accord.3.6.0\lib\net462\Accord.dll</HintPath>
-    </Reference>
-    <Reference Include="Accord.Math, Version=3.6.0.0, Culture=neutral, PublicKeyToken=fa1a88e29555ccf7, processorArchitecture=MSIL">
-      <HintPath>..\packages\Accord.Math.3.6.0\lib\net462\Accord.Math.dll</HintPath>
-    </Reference>
-    <Reference Include="Accord.Math.Core, Version=3.6.0.0, Culture=neutral, PublicKeyToken=fa1a88e29555ccf7, processorArchitecture=MSIL">
-      <HintPath>..\packages\Accord.Math.3.6.0\lib\net462\Accord.Math.Core.dll</HintPath>
-    </Reference>
-    <Reference Include="Accord.Statistics, Version=3.6.0.0, Culture=neutral, PublicKeyToken=fa1a88e29555ccf7, processorArchitecture=MSIL">
-      <HintPath>..\packages\Accord.Statistics.3.6.0\lib\net462\Accord.Statistics.dll</HintPath>
-    </Reference>
-    <Reference Include="MathNet.Numerics, Version=3.19.0.0, Culture=neutral, processorArchitecture=MSIL">
-      <HintPath>..\packages\MathNet.Numerics.3.19.0\lib\net40\MathNet.Numerics.dll</HintPath>
-    </Reference>
-    <Reference Include="NodaTime, Version=1.3.0.0, Culture=neutral, PublicKeyToken=4226afe0d9b296d1, processorArchitecture=MSIL">
-      <HintPath>..\packages\NodaTime.1.3.4\lib\net35-Client\NodaTime.dll</HintPath>
-    </Reference>
-    <Reference Include="System" />
-    <Reference Include="System.Core" />
-    <Reference Include="System.Numerics" />
-    <Reference Include="System.Xml.Linq" />
-    <Reference Include="System.Data.DataSetExtensions" />
-    <Reference Include="Microsoft.CSharp" />
-    <Reference Include="System.Data" />
-    <Reference Include="System.Xml" />
-  </ItemGroup>
   <PropertyGroup>
     <IsWindows>false</IsWindows>
     <IsWindows Condition="'$(OS)' == 'Windows_NT'">true</IsWindows>
@@ -85,94 +41,59 @@
     <Message Text="IsLinux $(IsLinux)" Importance="high" />
     <Message Text="ForceLinuxBuild $(ForceLinuxBuild)" Importance="high" />
   </Target>
+  <ItemGroup>
+    <PackageReference Include="Accord" Version="3.6.0" />
+    <PackageReference Include="Accord.Math" Version="3.6.0" />
+    <PackageReference Include="Accord.Statistics" Version="3.6.0" />
+    <PackageReference Include="MathNet.Numerics" Version="3.19.0" />
+    <PackageReference Include="Microsoft.CodeAnalysis.FxCopAnalyzers" Version="2.9.3" />
+    <PackageReference Include="Microsoft.CodeAnalysis.VersionCheckAnalyzer" Version="2.9.3" />
+    <PackageReference Include="Microsoft.CodeQuality.Analyzers" Version="2.9.3" />
+    <PackageReference Include="Microsoft.Net.Compilers" Version="2.10.0">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+    <PackageReference Include="Microsoft.NetCore.Analyzers" Version="2.9.3" />
+    <PackageReference Include="Microsoft.NetFramework.Analyzers" Version="2.9.3" />
+    <PackageReference Include="NodaTime" Version="3.0.5" />
+    <PackageReference Include="QuantConnect.pythonnet" Version="1.0.5.30" />
+  </ItemGroup>
   <Choose>
     <When Condition="$(IsWindows) AND '$(ForceLinuxBuild)' != 'true'">
       <ItemGroup>
         <Reference Include="Python.Runtime, Version=1.0.5.30, Culture=neutral, processorArchitecture=MSIL">
-          <HintPath>..\packages\QuantConnect.pythonnet.1.0.5.30\lib\win\Python.Runtime.dll</HintPath>
+          <HintPath>$(NuGetPackageRoot)\quantconnect.pythonnet\1.0.5.30\lib\win\Python.Runtime.dll</HintPath>
         </Reference>
       </ItemGroup>
     </When>
     <When Condition="$(IsLinux) OR '$(ForceLinuxBuild)' == 'true'">
       <ItemGroup>
         <Reference Include="Python.Runtime, Version=1.0.5.30, Culture=neutral, processorArchitecture=MSIL">
-          <HintPath>..\packages\QuantConnect.pythonnet.1.0.5.30\lib\linux\Python.Runtime.dll</HintPath>
+          <HintPath>$(NuGetPackageRoot)\quantconnect.pythonnet\1.0.5.30\lib\linux\Python.Runtime.dll</HintPath>
         </Reference>
       </ItemGroup>
     </When>
     <When Condition="$(IsOSX) AND '$(ForceLinuxBuild)' != 'true'">
       <ItemGroup>
         <Reference Include="Python.Runtime, Version=1.0.5.30, Culture=neutral, processorArchitecture=MSIL">
-          <HintPath>..\packages\QuantConnect.pythonnet.1.0.5.30\lib\osx\Python.Runtime.dll</HintPath>
+          <HintPath>$(NuGetPackageRoot)\quantconnect.pythonnet\1.0.5.30\lib\osx\Python.Runtime.dll</HintPath>
         </Reference>
       </ItemGroup>
     </When>
   </Choose>
   <ItemGroup>
-    <Compile Include="..\Common\Properties\SharedAssemblyInfo.cs">
-      <Link>Properties\SharedAssemblyInfo.cs</Link>
-    </Compile>
-    <Compile Include="Alphas\PearsonCorrelationPairsTradingAlphaModel.cs" />
-    <Compile Include="Alphas\EmaCrossAlphaModel.cs" />
-    <Compile Include="Alphas\BasePairsTradingAlphaModel.cs" />
-    <Compile Include="Alphas\RsiAlphaModel.cs" />
-    <Compile Include="Execution\StandardDeviationExecutionModel.cs" />
-    <Compile Include="Execution\VolumeWeightedAveragePriceExecutionModel.cs" />
-    <Compile Include="NotifiedSecurityChanges.cs" />
-    <Compile Include="Portfolio\BlackLittermanOptimizationPortfolioConstructionModel.cs" />
-    <Compile Include="Portfolio\ConfidenceWeightedPortfolioConstructionModel.cs" />
-    <Compile Include="Portfolio\SectorWeightingPortfolioConstructionModel.cs" />
-    <Compile Include="Portfolio\InsightWeightingPortfolioConstructionModel.cs" />
-    <Compile Include="Portfolio\UnconstrainedMeanVariancePortfolioOptimizer.cs" />
-    <Compile Include="Portfolio\MaximumSharpeRatioPortfolioOptimizer.cs" />
-    <Compile Include="Portfolio\MeanVarianceOptimizationPortfolioConstructionModel.cs" />
-    <Compile Include="Portfolio\MinimumVariancePortfolioOptimizer.cs" />
-    <Compile Include="Portfolio\EqualWeightingPortfolioConstructionModel.cs" />
-    <Compile Include="Portfolio\AccumulativeInsightPortfolioConstructionModel.cs" />
-    <Compile Include="Portfolio\ReturnsSymbolData.cs" />
-    <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="Risk\MaximumDrawdownPercentPortfolio.cs" />
-    <Compile Include="Risk\MaximumDrawdownPercentPerSecurity.cs" />
-    <Compile Include="Risk\MaximumSectorExposureRiskManagementModel.cs" />
-    <Compile Include="Risk\MaximumUnrealizedProfitPercentPerSecurity.cs" />
-    <Compile Include="Risk\TrailingStopRiskManagementModel.cs" />
-    <Compile Include="Selection\CoarseFundamentalUniverseSelectionModel.cs" />
-    <Compile Include="Selection\LiquidETFUniverse.cs" />
-    <Compile Include="Selection\FineFundamentalUniverseSelectionModel.cs" />
-    <Compile Include="Selection\FundamentalUniverseSelectionModel.cs" />
-    <Compile Include="Selection\EmaCrossUniverseSelectionModel.cs" />
-    <Compile Include="Alphas\ConstantAlphaModel.cs" />
-    <Compile Include="Alphas\MacdAlphaModel.cs" />
-    <Compile Include="Selection\FutureUniverseSelectionModel.cs" />
-    <Compile Include="Selection\OpenInterestFutureUniverseSelectionModel.cs" />
-    <Compile Include="Selection\OptionUniverseSelectionModel.cs" />
-    <Compile Include="Selection\ScheduledUniverseSelectionModel.cs" />
-    <Compile Include="Selection\QC500UniverseSelectionModel.cs" />
-    <Compile Include="Alphas\HistoricalReturnsAlphaModel.cs" />
-    <Compile Include="Selection\InceptionDateUniverseSelectionModel.cs" />
-    <Compile Include="Selection\EnergyETFUniverse.cs" />
-    <Compile Include="Selection\MetalsETFUniverse.cs" />
-    <Compile Include="Selection\SP500SectorsETFUniverse.cs" />
-    <Compile Include="Selection\TechnologyETFUniverse.cs" />
-    <Compile Include="Selection\USTreasuriesETFUniverse.cs" />
-    <Compile Include="Selection\VolatilityETFUniverse.cs" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
   </ItemGroup>
   <ItemGroup>
-    <ProjectReference Include="..\Algorithm\QuantConnect.Algorithm.csproj">
-      <Project>{3240ACA4-BDD4-4D24-AC36-BBB651C39212}</Project>
-      <Name>QuantConnect.Algorithm</Name>
-    </ProjectReference>
-    <ProjectReference Include="..\Common\QuantConnect.csproj">
-      <Project>{2545C0B4-FABB-49C9-8DD1-9AD7EE23F86B}</Project>
-      <Name>QuantConnect</Name>
-    </ProjectReference>
-    <ProjectReference Include="..\Indicators\QuantConnect.Indicators.csproj">
-      <Project>{73fb2522-c3ed-4e47-8e3d-afad48a6b888}</Project>
-      <Name>QuantConnect.Indicators</Name>
-    </ProjectReference>
+    <Compile Include="..\Common\Properties\SharedAssemblyInfo.cs" Link="Properties\SharedAssemblyInfo.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\Algorithm\QuantConnect.Algorithm.csproj" />
+    <ProjectReference Include="..\Common\QuantConnect.csproj" />
+    <ProjectReference Include="..\Indicators\QuantConnect.Indicators.csproj" />
   </ItemGroup>
   <ItemGroup>
-    <None Include="packages.config" />
     <Content Include="Portfolio\BlackLittermanOptimizationPortfolioConstructionModel.py">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>
@@ -268,29 +189,4 @@
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>
   </ItemGroup>
-  <ItemGroup>
-    <Analyzer Include="..\packages\Microsoft.CodeAnalysis.VersionCheckAnalyzer.2.9.3\analyzers\dotnet\Microsoft.CodeAnalysis.VersionCheckAnalyzer.dll" />
-    <Analyzer Include="..\packages\Microsoft.CodeQuality.Analyzers.2.9.3\analyzers\dotnet\cs\Humanizer.dll" />
-    <Analyzer Include="..\packages\Microsoft.CodeQuality.Analyzers.2.9.3\analyzers\dotnet\cs\Microsoft.CodeQuality.Analyzers.dll" />
-    <Analyzer Include="..\packages\Microsoft.CodeQuality.Analyzers.2.9.3\analyzers\dotnet\cs\Microsoft.CodeQuality.CSharp.Analyzers.dll" />
-    <Analyzer Include="..\packages\Microsoft.NetCore.Analyzers.2.9.3\analyzers\dotnet\cs\Microsoft.NetCore.Analyzers.dll" />
-    <Analyzer Include="..\packages\Microsoft.NetCore.Analyzers.2.9.3\analyzers\dotnet\cs\Microsoft.NetCore.CSharp.Analyzers.dll" />
-    <Analyzer Include="..\packages\Microsoft.NetFramework.Analyzers.2.9.3\analyzers\dotnet\cs\Microsoft.NetFramework.Analyzers.dll" />
-    <Analyzer Include="..\packages\Microsoft.NetFramework.Analyzers.2.9.3\analyzers\dotnet\cs\Microsoft.NetFramework.CSharp.Analyzers.dll" />
-  </ItemGroup>
-  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
-  <Import Project="..\packages\QuantConnect.pythonnet.1.0.5.30\build\QuantConnect.pythonnet.targets" Condition="Exists('..\packages\QuantConnect.pythonnet.1.0.5.30\build\QuantConnect.pythonnet.targets')" />
-  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
-    <PropertyGroup>
-      <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
-    </PropertyGroup>
-    <Error Condition="!Exists('..\packages\QuantConnect.pythonnet.1.0.5.30\build\QuantConnect.pythonnet.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\QuantConnect.pythonnet.1.0.5.30\build\QuantConnect.pythonnet.targets'))" />
-    <Error Condition="!Exists('..\packages\Microsoft.CodeAnalysis.VersionCheckAnalyzer.2.9.3\build\Microsoft.CodeAnalysis.VersionCheckAnalyzer.props')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\Microsoft.CodeAnalysis.VersionCheckAnalyzer.2.9.3\build\Microsoft.CodeAnalysis.VersionCheckAnalyzer.props'))" />
-    <Error Condition="!Exists('..\packages\Microsoft.CodeQuality.Analyzers.2.9.3\build\Microsoft.CodeQuality.Analyzers.props')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\Microsoft.CodeQuality.Analyzers.2.9.3\build\Microsoft.CodeQuality.Analyzers.props'))" />
-    <Error Condition="!Exists('..\packages\Microsoft.NetCore.Analyzers.2.9.3\build\Microsoft.NetCore.Analyzers.props')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\Microsoft.NetCore.Analyzers.2.9.3\build\Microsoft.NetCore.Analyzers.props'))" />
-    <Error Condition="!Exists('..\packages\Microsoft.NetFramework.Analyzers.2.9.3\build\Microsoft.NetFramework.Analyzers.props')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\Microsoft.NetFramework.Analyzers.2.9.3\build\Microsoft.NetFramework.Analyzers.props'))" />
-    <Error Condition="!Exists('..\packages\Microsoft.CodeAnalysis.FxCopAnalyzers.2.9.3\build\Microsoft.CodeAnalysis.FxCopAnalyzers.props')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\Microsoft.CodeAnalysis.FxCopAnalyzers.2.9.3\build\Microsoft.CodeAnalysis.FxCopAnalyzers.props'))" />
-    <Error Condition="!Exists('..\packages\Accord.3.6.0\build\Accord.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\Accord.3.6.0\build\Accord.targets'))" />
-  </Target>
-  <Import Project="..\packages\Accord.3.6.0\build\Accord.targets" Condition="Exists('..\packages\Accord.3.6.0\build\Accord.targets')" />
 </Project>

Algorithm.Framework/Selection/OptionUniverseSelectionModel.cs

@@ -96,9 +96,9 @@ namespace QuantConnect.Algorithm.Framework.Selection
             var uniqueUnderlyingSymbols = new HashSet<Symbol>();
             foreach (var optionSymbol in _optionChainSymbolSelector(algorithm.UtcTime))
             {
-                if (optionSymbol.SecurityType != SecurityType.Option)
+                if (optionSymbol.SecurityType != SecurityType.Option && optionSymbol.SecurityType != SecurityType.FutureOption)
                 {
-                    throw new ArgumentException("optionChainSymbolSelector must return option symbols.");
+                    throw new ArgumentException("optionChainSymbolSelector must return option or futures options symbols.");
                 }
 
                 // prevent creating duplicate option chains -- one per underlying
@@ -118,4 +118,4 @@ namespace QuantConnect.Algorithm.Framework.Selection
             return filter;
         }
     }
-}
+}

Algorithm.Framework/Selection/OptionUniverseSelectionModel.py

@@ -58,8 +58,8 @@ class OptionUniverseSelectionModel(UniverseSelectionModel):
 
         uniqueUnderlyingSymbols = set()
         for optionSymbol in self.optionChainSymbolSelector(algorithm.UtcTime):
-            if optionSymbol.SecurityType != SecurityType.Option:
-                raise ValueError("optionChainSymbolSelector must return option symbols.")
+            if optionSymbol.SecurityType != SecurityType.Option and optionSymbol.SecurityType != SecurityType.FutureOption:
+                raise ValueError("optionChainSymbolSelector must return option or futures options symbols.")
 
             # prevent creating duplicate option chains -- one per underlying
             if optionSymbol.Underlying not in uniqueUnderlyingSymbols:
@@ -73,7 +73,7 @@ class OptionUniverseSelectionModel(UniverseSelectionModel):
             symbol: Symbol of the option
         Returns:
             OptionChainUniverse for the given symbol'''
-        if symbol.SecurityType != SecurityType.Option:
+        if symbol.SecurityType != SecurityType.Option and symbol.SecurityType != SecurityType.FutureOption:
             raise ValueError("CreateOptionChain requires an option symbol.")
 
         # rewrite non-canonical symbols to be canonical
@@ -122,4 +122,4 @@ class OptionUniverseSelectionModel(UniverseSelectionModel):
     def Filter(self, filter):
         '''Defines the option chain universe filter'''
         # NOP
-        return filter
+        return filter

Algorithm.Framework/packages.config

@@ -1,14 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="Accord" version="3.6.0" targetFramework="net462" />
-  <package id="Accord.Math" version="3.6.0" targetFramework="net462" />
-  <package id="Accord.Statistics" version="3.6.0" targetFramework="net462" />
-  <package id="MathNet.Numerics" version="3.19.0" targetFramework="net452" />
-  <package id="Microsoft.CodeAnalysis.FxCopAnalyzers" version="2.9.3" targetFramework="net452" />
-  <package id="Microsoft.CodeAnalysis.VersionCheckAnalyzer" version="2.9.3" targetFramework="net452" />
-  <package id="Microsoft.CodeQuality.Analyzers" version="2.9.3" targetFramework="net452" />
-  <package id="Microsoft.NetCore.Analyzers" version="2.9.3" targetFramework="net452" />
-  <package id="Microsoft.NetFramework.Analyzers" version="2.9.3" targetFramework="net452" />
-  <package id="NodaTime" version="1.3.4" targetFramework="net452" />
-  <package id="QuantConnect.pythonnet" version="1.0.5.30" targetFramework="net452" />
-</packages>

Algorithm.Python/.idea/Algorithm.Python.iml

@@ -1,10 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module type="PYTHON_MODULE" version="4">
-  <component name="NewModuleRootManager">
-    <content url="file://$MODULE_DIR$">
-      <sourceFolder url="file://$MODULE_DIR$/stubs" isTestSource="false" />
-    </content>
-    <orderEntry type="inheritedJdk" />
-    <orderEntry type="sourceFolder" forTests="false" />
-  </component>
-</module>

Algorithm.Python/.idea/misc.xml

@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.6" project-jdk-type="Python SDK" />
-</project>

Algorithm.Python/.idea/modules.xml

@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ProjectModuleManager">
-    <modules>
-      <module fileurl="file://$PROJECT_DIR$/.idea/Algorithm.Python.iml" filepath="$PROJECT_DIR$/.idea/Algorithm.Python.iml" />
-    </modules>
-  </component>
-</project>

Algorithm.Python/.vscode/settings.json

@@ -1,5 +0,0 @@
-{
-    "python.autoComplete.extraPaths": [
-        "stubs"
-    ]
-}

Algorithm.Python/AddFutureOptionContractDataStreamingRegressionAlgorithm.py

@@ -0,0 +1,103 @@
+# QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+# Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from datetime import datetime, timedelta
+
+from QuantConnect import *
+from QuantConnect.Algorithm import *
+from QuantConnect.Data import *
+from QuantConnect.Data.Market import *
+from QuantConnect.Securities import *
+from QuantConnect.Securities.Future import *
+from QuantConnect import Market
+
+### <summary>
+### This regression algorithm tests that we receive the expected data when
+### we add future option contracts individually using <see cref="AddFutureOptionContract"/>
+### </summary>
+class AddFutureOptionContractDataStreamingRegressionAlgorithm(QCAlgorithm):
+    def Initialize(self):
+        self.onDataReached = False
+        self.invested = False
+        self.symbolsReceived = []
+        self.expectedSymbolsReceived = []
+        self.dataReceived = {}
+
+        self.SetStartDate(2020, 1, 5)
+        self.SetEndDate(2020, 1, 6)
+
+        self.es20h20 = self.AddFutureContract(
+            Symbol.CreateFuture(Futures.Indices.SP500EMini, Market.CME, datetime(2020, 3, 20)),
+            Resolution.Minute).Symbol
+
+        self.es19m20 = self.AddFutureContract(
+            Symbol.CreateFuture(Futures.Indices.SP500EMini, Market.CME, datetime(2020, 6, 19)),
+            Resolution.Minute).Symbol
+
+        optionChains = self.OptionChainProvider.GetOptionContractList(self.es20h20, self.Time)
+        optionChains += self.OptionChainProvider.GetOptionContractList(self.es19m20, self.Time)
+
+        for optionContract in optionChains:
+            self.expectedSymbolsReceived.append(self.AddFutureOptionContract(optionContract, Resolution.Minute).Symbol)
+
+    def OnData(self, data: Slice):
+        if not data.HasData:
+            return
+
+        self.onDataReached = True
+        hasOptionQuoteBars = False
+
+        for qb in data.QuoteBars.Values:
+            if qb.Symbol.SecurityType != SecurityType.FutureOption:
+                continue
+
+            hasOptionQuoteBars = True
+
+            self.symbolsReceived.append(qb.Symbol)
+            if qb.Symbol not in self.dataReceived:
+                self.dataReceived[qb.Symbol] = []
+
+            self.dataReceived[qb.Symbol].append(qb)
+
+        if self.invested or not hasOptionQuoteBars:
+            return
+
+        if data.ContainsKey(self.es20h20) and data.ContainsKey(self.es19m20):
+            self.SetHoldings(self.es20h20, 0.2)
+            self.SetHoldings(self.es19m20, 0.2)
+
+            self.invested = True
+
+    def OnEndOfAlgorithm(self):
+        super().OnEndOfAlgorithm()
+
+        self.symbolsReceived = list(set(self.symbolsReceived))
+        self.expectedSymbolsReceived = list(set(self.expectedSymbolsReceived))
+
+        if not self.onDataReached:
+            raise AssertionError("OnData() was never called.")
+        if len(self.symbolsReceived) != len(self.expectedSymbolsReceived):
+            raise AssertionError(f"Expected {len(self.expectedSymbolsReceived)} option contracts Symbols, found {len(self.symbolsReceived)}")
+
+        missingSymbols = [expectedSymbol for expectedSymbol in self.expectedSymbolsReceived if expectedSymbol not in self.symbolsReceived]
+        if any(missingSymbols):
+            raise AssertionError(f'Symbols: "{", ".join(missingSymbols)}" were not found in OnData')
+
+        for expectedSymbol in self.expectedSymbolsReceived:
+            data = self.dataReceived[expectedSymbol]
+            for dataPoint in data:
+                dataPoint.EndTime = datetime(1970, 1, 1)
+
+            nonDupeDataCount = len(set(data))
+            if nonDupeDataCount < 1000:
+                raise AssertionError(f"Received too few data points. Expected >=1000, found {nonDupeDataCount} for {expectedSymbol}")

Algorithm.Python/AddFutureOptionSingleOptionChainSelectedInUniverseFilterRegressionAlgorithm.py

@@ -0,0 +1,127 @@
+# QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+# Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from datetime import datetime, timedelta
+
+from QuantConnect.Algorithm import *
+from QuantConnect.Data import *
+from QuantConnect.Data.Market import *
+from QuantConnect.Securities import *
+from QuantConnect.Securities.Future import *
+from QuantConnect import *
+
+### <summary>
+### This regression algorithm tests that we only receive the option chain for a single future contract
+### in the option universe filter.
+### </summary>
+class AddFutureOptionSingleOptionChainSelectedInUniverseFilterRegressionAlgorithm(QCAlgorithm):
+    def Initialize(self):
+        self.invested = False
+        self.onDataReached = False
+        self.optionFilterRan = False
+        self.symbolsReceived = []
+        self.expectedSymbolsReceived = []
+        self.dataReceived = {}
+
+        self.SetStartDate(2020, 1, 5)
+        self.SetEndDate(2020, 1, 6)
+
+        self.es = self.AddFuture(Futures.Indices.SP500EMini, Resolution.Minute, Market.CME)
+        self.es.SetFilter(lambda futureFilter: futureFilter.Expiration(0, 365).ExpirationCycle([3, 6]))
+
+        self.AddFutureOption(self.es.Symbol, self.OptionContractUniverseFilterFunction)
+
+    def OptionContractUniverseFilterFunction(self, optionContracts: OptionFilterUniverse) -> OptionFilterUniverse:
+        self.optionFilterRan = True
+
+        expiry = list(set([x.Underlying.ID.Date for x in optionContracts]))
+        expiry = None if not any(expiry) else expiry[0]
+
+        symbol = [x.Underlying for x in optionContracts]
+        symbol = None if not any(symbol) else symbol[0]
+
+        if expiry is None or symbol is None:
+            raise AssertionError("Expected a single Option contract in the chain, found 0 contracts")
+
+        enumerator = optionContracts.GetEnumerator()
+        while enumerator.MoveNext():
+            self.expectedSymbolsReceived.append(enumerator.Current)
+
+        return optionContracts
+
+    def OnData(self, data: Slice):
+        if not data.HasData:
+            return
+
+        self.onDataReached = True
+        hasOptionQuoteBars = False
+
+        for qb in data.QuoteBars.Values:
+            if qb.Symbol.SecurityType != SecurityType.FutureOption:
+                continue
+
+            hasOptionQuoteBars = True
+
+            self.symbolsReceived.append(qb.Symbol)
+            if qb.Symbol not in self.dataReceived:
+                self.dataReceived[qb.Symbol] = []
+
+            self.dataReceived[qb.Symbol].append(qb)
+
+        if self.invested or not hasOptionQuoteBars:
+            return
+
+        for chain in data.OptionChains.Values:
+            futureInvested = False
+            optionInvested = False
+
+            for option in chain.Contracts.Keys:
+                if futureInvested and optionInvested:
+                    return
+
+                future = option.Underlying
+
+                if not optionInvested and data.ContainsKey(option):
+                    self.MarketOrder(option, 1)
+                    self.invested = True
+                    optionInvested = True
+
+                if not futureInvested and data.ContainsKey(future):
+                    self.MarketOrder(future, 1)
+                    self.invested = True
+                    futureInvested = True
+
+    def OnEndOfAlgorithm(self):
+        super().OnEndOfAlgorithm()
+        self.symbolsReceived = list(set(self.symbolsReceived))
+        self.expectedSymbolsReceived = list(set(self.expectedSymbolsReceived))
+
+        if not self.optionFilterRan:
+            raise AssertionError("Option chain filter was never ran")
+        if not self.onDataReached:
+            raise AssertionError("OnData() was never called.")
+        if len(self.symbolsReceived) != len(self.expectedSymbolsReceived):
+            raise AssertionError(f"Expected {len(self.expectedSymbolsReceived)} option contracts Symbols, found {len(self.symbolsReceived)}")
+
+        missingSymbols = [expectedSymbol for expectedSymbol in self.expectedSymbolsReceived if expectedSymbol not in self.symbolsReceived]
+        if any(missingSymbols):
+            raise AssertionError(f'Symbols: "{", ".join(missingSymbols)}" were not found in OnData')
+
+        for expectedSymbol in self.expectedSymbolsReceived:
+            data = self.dataReceived[expectedSymbol]
+            for dataPoint in data:
+                dataPoint.EndTime = datetime(1970, 1, 1)
+
+            nonDupeDataCount = len(set(data))
+            if nonDupeDataCount < 1000:
+                raise AssertionError(f"Received too few data points. Expected >=1000, found {nonDupeDataCount} for {expectedSymbol}")

Algorithm.Python/AllShortableSymbolsCoarseSelectionRegressionAlgorithm.py

@@ -0,0 +1,111 @@
+### QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+### Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+###
+### Licensed under the Apache License, Version 2.0 (the "License");
+### you may not use this file except in compliance with the License.
+### You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+###
+### Unless required by applicable law or agreed to in writing, software
+### distributed under the License is distributed on an "AS IS" BASIS,
+### WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+### See the License for the specific language governing permissions and
+### limitations under the License.
+
+from datetime import date
+
+import QuantConnect 
+from QuantConnect import *
+from QuantConnect.Algorithm import *
+from QuantConnect.Brokerages import *
+from QuantConnect.Data import *
+from QuantConnect.Data.Shortable import *
+from QuantConnect.Data.UniverseSelection import *
+from QuantConnect.Interfaces import *
+from QuantConnect import *
+
+
+class AllShortableSymbolsRegressionAlgorithmBrokerageModel(DefaultBrokerageModel):
+    def __init__(self):
+        self.ShortableProvider = LocalDiskShortableProvider(SecurityType.Equity, "testbrokerage", Market.USA)
+
+### <summary>
+### Tests filtering in coarse selection by shortable quantity
+### </summary>
+class AllShortableSymbolsCoarseSelectionRegressionAlgorithm(QCAlgorithm):
+    def Initialize(self):
+        self._20140325 = date(2014, 3, 25);
+        self._20140326 = date(2014, 3, 26);
+        self._20140327 = date(2014, 3, 27);
+        self._20140328 = date(2014, 3, 28);
+        self._20140329 = date(2014, 3, 29);
+
+        self.aapl = QuantConnect.Symbol.Create("AAPL", SecurityType.Equity, Market.USA);
+        self.bac = QuantConnect.Symbol.Create("BAC", SecurityType.Equity, Market.USA);
+        self.gme = QuantConnect.Symbol.Create("GME", SecurityType.Equity, Market.USA);
+        self.goog = QuantConnect.Symbol.Create("GOOG", SecurityType.Equity, Market.USA);
+        self.qqq = QuantConnect.Symbol.Create("QQQ", SecurityType.Equity, Market.USA);
+        self.spy = QuantConnect.Symbol.Create("SPY", SecurityType.Equity, Market.USA);
+        self.lastTradeDate = date(1, 1, 1);
+
+        self.coarseSelected = {
+            self._20140325: False,
+            self._20140326: False,
+            self._20140327: False,
+            self._20140328: False
+        }
+
+        self.expectedSymbols = {
+            self._20140325: [self.bac, self.qqq, self.spy],
+            self._20140326: [self.spy],
+            self._20140327: [self.aapl, self.bac, self.gme, self.qqq, self.spy],
+            self._20140328: [self.goog],
+            self._20140329: []
+        }
+
+        self.SetStartDate(2014, 3, 25);
+        self.SetEndDate(2014, 3, 29);
+        self.SetCash(10000000);
+
+        self.AddUniverse(self.CoarseSelectionFunc);
+        self.UniverseSettings.Resolution = QuantConnect.Resolution.Daily;
+
+        self.SetBrokerageModel(AllShortableSymbolsRegressionAlgorithmBrokerageModel());
+
+    def OnData(self, data):
+        if self.Time.date() == self.lastTradeDate:
+            return
+
+        for symbol in self.ActiveSecurities.Keys:
+            if not symbol in self.Portfolio or not self.Portfolio[symbol].Invested:
+                if not self.Shortable(symbol):
+                    raise Exception(f"Expected {symbol} to be shortable on {self.Time}")
+
+                # Buy at least once into all Symbols. Since daily data will always use
+                # MOO orders, it makes the testing of liquidating buying into Symbols difficult
+                self.MarketOrder(symbol, -float(self.ShortableQuantity(symbol)))
+                self.lastTradeDate = self.Time.date()
+
+    def CoarseSelectionFunc(self, coarse):
+        shortableSymbols = self.AllShortableSymbols();
+        selectedSymbols = list(sorted([x.Symbol for x in coarse if x.Symbol in shortableSymbols and shortableSymbols[x.Symbol] >= 500]))
+
+        expectedMissing = 0;
+        if self.Time.date() == self._20140327:
+            gme = QuantConnect.Symbol.Create("GME", SecurityType.Equity, Market.USA);
+            if gme not in shortableSymbols:
+                raise Exception("Expected unmapped GME in shortable symbols list on 2014-03-27");
+            if len([x.Symbol.Value for x in coarse if x.Symbol.Value == "GME"]) == 0:
+                raise Exception("Expected mapped GME in coarse symbols on 2014-03-27");
+
+            expectedMissing = 1;
+
+        missing = [i for i in self.expectedSymbols[self.Time.date()] if i not in selectedSymbols]
+        if (len(missing) != expectedMissing):
+            raise Exception(f"Expected Symbols selected on {self.Time.date()} to match expected Symbols, but the following Symbols were missing: {', '.join([str(s) for s in missing])}")
+
+        self.coarseSelected[self.Time.date()] = True;
+        return selectedSymbols
+
+    def OnEndOfAlgorithm(self):
+        if not all(list(self.coarseSelected.values())):
+            raise Exception(f"Expected coarse selection on all dates, but didn't run on: {', '.join([str(k) for k, v in self.coarseSelected.items() if not v])}")

Algorithm.Python/AltData/QuiverWallStreetBetsDataAlgorithm.py

@@ -0,0 +1,50 @@
+# QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+# Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from clr import AddReference
+AddReference("System")
+AddReference("QuantConnect.Algorithm")
+AddReference("QuantConnect.Common")
+
+from System import *
+from QuantConnect import *
+from QuantConnect.Algorithm import *
+from QuantConnect.Data import *
+from QuantConnect.Data.Custom.Quiver import *
+
+### <summary>
+### Quiver Quantitative is a provider of alternative data.
+### This algorithm shows how to consume the 'QuiverWallStreetBets'
+### </summary>
+class QuiverWallStreetBetsDataAlgorithm(QCAlgorithm):
+    def Initialize(self):
+        self.SetStartDate(2019, 1, 1)
+        self.SetEndDate(2020, 6, 1)
+        self.SetCash(100000)
+
+        aapl = self.AddEquity("AAPL", Resolution.Daily).Symbol
+        quiverWSBSymbol = self.AddData(QuiverWallStreetBets, aapl).Symbol
+        history = self.History(QuiverWallStreetBets, quiverWSBSymbol, 60, Resolution.Daily)
+
+        self.Debug(f"We got {len(history)} items from our history request");
+
+    def OnData(self, data):
+        points = data.Get(QuiverWallStreetBets)
+        for point in points.Values:
+            # Go long in the stock if it was mentioned more than 5 times in the WallStreetBets daily discussion
+            if point.Mentions > 5:
+                self.SetHoldings(point.Symbol.Underlying, 1)
+
+            # Go short in the stock if it was mentioned less than 5 times in the WallStreetBets daily discussion
+            if point.Mentions < 5:
+                self.SetHoldings(point.Symbol.Underlying, -1)

Algorithm.Python/AutoRegressiveIntegratedMovingAverageRegressionAlgorithm.py

@@ -0,0 +1,51 @@
+# QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+# Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from clr import AddReference
+
+AddReference("System")
+AddReference("QuantConnect.Algorithm")
+AddReference("QuantConnect.Common")
+
+from System import *
+from QuantConnect import *
+from QuantConnect.Algorithm import *
+
+# <summary>
+# Regression algorithm to test the behaviour of ARMA versus AR models at the same order of differencing.
+# In particular, an ARIMA(1,1,1) and ARIMA(1,1,0) are instantiated while orders are placed if their difference
+# is sufficiently large (which would be due to the inclusion of the MA(1) term).
+# </summary>
+class AutoRegressiveIntegratedMovingAverageRegressionAlgorithm(QCAlgorithm):
+    def Initialize(self):
+        '''Initialise the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must initialized.'''
+        self.SetStartDate(2013, 1, 7)
+        self.SetEndDate(2013, 12, 11)
+        self.EnableAutomaticIndicatorWarmUp = True
+        self.AddEquity("SPY", Resolution.Daily)
+        self.arima = self.ARIMA("SPY", 1, 1, 1, 50)
+        self.ar = self.ARIMA("SPY", 1, 1, 0, 50)
+
+    def OnData(self, data):
+        '''OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here.
+
+        Arguments:
+            data: Slice object keyed by symbol containing the stock data
+        '''
+        if self.arima.IsReady:
+            if abs(self.arima.Current.Value - self.ar.Current.Value) > 1:
+                if self.arima.Current.Value > self.last:
+                    self.MarketOrder("SPY", 1)
+                else:
+                    self.MarketOrder("SPY", -1)
+            self.last = self.arima.Current.Value

Algorithm.Python/CustomBenchmarkAlgorithm.py

@@ -35,7 +35,11 @@ class CustomBenchmarkAlgorithm(QCAlgorithm):
         self.SetCash(100000)           #Set Strategy Cash
         # Find more symbols here: http://quantconnect.com/data
         self.AddEquity("SPY", Resolution.Second)
-
+        
+        # Disabling the benchmark / setting to a fixed value 
+        # self.SetBenchmark(lambda x: 0)
+        
+        # Set the benchmark to AAPL US Equity
         self.SetBenchmark(Symbol.Create("AAPL", SecurityType.Equity, Market.USA))
 
     def OnData(self, data):
@@ -46,4 +50,4 @@ class CustomBenchmarkAlgorithm(QCAlgorithm):
 
         tupleResult = SymbolCache.TryGetSymbol("AAPL", None)
         if tupleResult[0]:
-            raise Exception("Benchmark Symbol is not expected to be added to the Symbol cache")
+            raise Exception("Benchmark Symbol is not expected to be added to the Symbol cache")

Algorithm.Python/CustomDataPropertiesRegressionAlgorithm.py

@@ -0,0 +1,140 @@
+# QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+# Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from clr import AddReference
+AddReference("System.Core")
+AddReference("QuantConnect.Common")
+AddReference("QuantConnect.Algorithm")
+AddReference("QuantConnect.Algorithm.Framework")
+
+from System import *
+from QuantConnect import *
+from QuantConnect.Algorithm import *
+from QuantConnect.Algorithm.Framework import *
+from QuantConnect.Data import SubscriptionDataSource
+from QuantConnect.Python import PythonData
+from QuantConnect.Securities import *
+
+from datetime import datetime
+import json
+
+### <summary>
+### Regression test to demonstrate setting custom Symbol Properties and Market Hours for a custom data import
+### </summary>
+### <meta name="tag" content="using data" />
+### <meta name="tag" content="importing data" />
+### <meta name="tag" content="custom data" />
+### <meta name="tag" content="crypto" />
+### <meta name="tag" content="regression test" />
+class CustomDataPropertiesRegressionAlgorithm(QCAlgorithm):
+
+    def Initialize(self):
+        self.SetStartDate(2011,9,13)   # Set Start Date
+        self.SetEndDate(2015,12,1)     # Set End Date
+        self.SetCash(100000)           # Set Strategy Cash
+        
+        # Define our custom data properties and exchange hours
+        self.ticker = 'BTC'
+        properties = SymbolProperties("Bitcoin", "USD", 1, 0.01, 0.01, self.ticker)
+        exchangeHours = SecurityExchangeHours.AlwaysOpen(TimeZones.NewYork)
+
+        # Add the custom data to our algorithm with our custom properties and exchange hours
+        self.bitcoin = self.AddData(Bitcoin, self.ticker, properties, exchangeHours)
+
+        # Verify our symbol properties were changed and loaded into this security
+        if self.bitcoin.SymbolProperties != properties :
+            raise Exception("Failed to set and retrieve custom SymbolProperties for BTC")
+
+        # Verify our exchange hours were changed and loaded into this security
+        if self.bitcoin.Exchange.Hours != exchangeHours :
+            raise Exception("Failed to set and retrieve custom ExchangeHours for BTC")
+
+        # For regression purposes on AddData overloads, this call is simply to ensure Lean can accept this
+        # with default params and is not routed to a breaking function.
+        self.AddData(Bitcoin, "BTCUSD");
+
+
+    def OnData(self, data):
+        if not self.Portfolio.Invested:
+            if data['BTC'].Close != 0 :
+                self.Order('BTC', self.Portfolio.MarginRemaining/abs(data['BTC'].Close + 1))
+
+    def OnEndOfAlgorithm(self):
+        #Reset our Symbol property value, for testing purposes.
+        self.SymbolPropertiesDatabase.SetEntry(Market.USA, self.MarketHoursDatabase.GetDatabaseSymbolKey(self.bitcoin.Symbol), SecurityType.Base,
+            SymbolProperties.GetDefault("USD"));
+
+
+
+class Bitcoin(PythonData):
+    '''Custom Data Type: Bitcoin data from Quandl - http://www.quandl.com/help/api-for-bitcoin-data'''
+
+    def GetSource(self, config, date, isLiveMode):
+        if isLiveMode:
+            return SubscriptionDataSource("https://www.bitstamp.net/api/ticker/", SubscriptionTransportMedium.Rest)
+
+        #return "http://my-ftp-server.com/futures-data-" + date.ToString("Ymd") + ".zip"
+        # OR simply return a fixed small data file. Large files will slow down your backtest
+        return SubscriptionDataSource("https://www.quantconnect.com/api/v2/proxy/quandl/api/v3/datasets/BCHARTS/BITSTAMPUSD.csv?order=asc&api_key=WyAazVXnq7ATy_fefTqm", SubscriptionTransportMedium.RemoteFile)
+
+
+    def Reader(self, config, line, date, isLiveMode):
+        coin = Bitcoin()
+        coin.Symbol = config.Symbol
+
+        if isLiveMode:
+            # Example Line Format:
+            # {"high": "441.00", "last": "421.86", "timestamp": "1411606877", "bid": "421.96", "vwap": "428.58", "volume": "14120.40683975", "low": "418.83", "ask": "421.99"}
+            try:
+                liveBTC = json.loads(line)
+
+                # If value is zero, return None
+                value = liveBTC["last"]
+                if value == 0: return None
+
+                coin.Time = datetime.now()
+                coin.Value = value
+                coin["Open"] = float(liveBTC["open"])
+                coin["High"] = float(liveBTC["high"])
+                coin["Low"] = float(liveBTC["low"])
+                coin["Close"] = float(liveBTC["last"])
+                coin["Ask"] = float(liveBTC["ask"])
+                coin["Bid"] = float(liveBTC["bid"])
+                coin["VolumeBTC"] = float(liveBTC["volume"])
+                coin["WeightedPrice"] = float(liveBTC["vwap"])
+                return coin
+            except ValueError:
+                # Do nothing, possible error in json decoding
+                return None
+
+        # Example Line Format:
+        # Date      Open   High    Low     Close   Volume (BTC)    Volume (Currency)   Weighted Price
+        # 2011-09-13 5.8    6.0     5.65    5.97    58.37138238,    346.0973893944      5.929230648356
+        if not (line.strip() and line[0].isdigit()): return None
+
+        try:
+            data = line.split(',')
+            coin.Time = datetime.strptime(data[0], "%Y-%m-%d")
+            coin.Value = float(data[4])
+            coin["Open"] = float(data[1])
+            coin["High"] = float(data[2])
+            coin["Low"] = float(data[3])
+            coin["Close"] = float(data[4])
+            coin["VolumeBTC"] = float(data[5])
+            coin["VolumeUSD"] = float(data[6])
+            coin["WeightedPrice"] = float(data[7])
+            return coin
+
+        except ValueError:
+            # Do nothing, possible error in json decoding
+            return None

Algorithm.Python/DelistingEventsAlgorithm.py

@@ -39,7 +39,7 @@ class DelistingEventsAlgorithm(QCAlgorithm):
         self.SetEndDate(2007, 5, 25)    #Set End Date
         self.SetCash(100000)             #Set Strategy Cash
         # Find more symbols here: http://quantconnect.com/data
-        self.AddEquity("AAA", Resolution.Daily)
+        self.AddEquity("AAA.1", Resolution.Daily)
         self.AddEquity("SPY", Resolution.Daily)
 
 
@@ -50,7 +50,7 @@ class DelistingEventsAlgorithm(QCAlgorithm):
             data: Slice object keyed by symbol containing the stock data
         '''
         if self.Transactions.OrdersCount == 0:
-            self.SetHoldings("AAA", 1)
+            self.SetHoldings("AAA.1", 1)
             self.Debug("Purchased stock")
 
         for kvp in data.Bars:
@@ -61,7 +61,7 @@ class DelistingEventsAlgorithm(QCAlgorithm):
 
         # the slice can also contain delisting data: data.Delistings in a dictionary string->Delisting
 
-        aaa = self.Securities["AAA"]
+        aaa = self.Securities["AAA.1"]
         if aaa.IsDelisted and aaa.IsTradable:
             raise Exception("Delisted security must NOT be tradable")
 

Algorithm.Python/FutureOptionBuySellCallIntradayRegressionAlgorithm.py

@@ -0,0 +1,92 @@
+# QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+# Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License
+
+from datetime import datetime, timedelta
+
+import clr
+from System import *
+from System.Reflection import *
+from QuantConnect import *
+from QuantConnect.Algorithm import *
+from QuantConnect.Data import *
+from QuantConnect.Data.Market import *
+from QuantConnect.Orders import *
+from QuantConnect.Securities import *
+from QuantConnect.Securities.Future import *
+from QuantConnect import Market
+
+
+### <summary>
+### This regression algorithm tests In The Money (ITM) future option calls across different strike prices.
+### We expect 6 orders from the algorithm, which are:
+###
+###   * (1) Initial entry, buy ES Call Option (ES19M20 expiring ITM)
+###   * (2) Initial entry, sell ES Call Option at different strike (ES20H20 expiring ITM)
+###   * [2] Option assignment, opens a position in the underlying (ES20H20, Qty: -1)
+###   * [2] Future contract liquidation, due to impending expiry
+###   * [1] Option exercise, receive 1 ES19M20 future contract
+###   * [1] Liquidate ES19M20 contract, due to expiry
+###
+### Additionally, we test delistings for future options and assert that our
+### portfolio holdings reflect the orders the algorithm has submitted.
+### </summary>
+class FutureOptionBuySellCallIntradayRegressionAlgorithm(QCAlgorithm):
+
+    def Initialize(self):
+        self.SetStartDate(2020, 1, 5)
+        self.SetEndDate(2020, 6, 30)
+
+        self.es20h20 = self.AddFutureContract(
+            Symbol.CreateFuture(
+                Futures.Indices.SP500EMini,
+                Market.CME,
+                datetime(2020, 3, 20)
+            ),
+            Resolution.Minute).Symbol
+
+        self.es19m20 = self.AddFutureContract(
+            Symbol.CreateFuture(
+                Futures.Indices.SP500EMini,
+                Market.CME,
+                datetime(2020, 6, 19)
+            ),
+            Resolution.Minute).Symbol
+
+        # Select a future option expiring ITM, and adds it to the algorithm.
+        self.esOptions = [
+            self.AddFutureOptionContract(i, Resolution.Minute).Symbol for i in (self.OptionChainProvider.GetOptionContractList(self.es19m20, self.Time) + self.OptionChainProvider.GetOptionContractList(self.es20h20, self.Time)) if i.ID.StrikePrice == 3200.0 and i.ID.OptionRight == OptionRight.Call
+        ]
+
+        self.expectedContracts = [
+            Symbol.CreateOption(self.es20h20, Market.CME, OptionStyle.American, OptionRight.Call, 3200.0, datetime(2020, 3, 20)),
+            Symbol.CreateOption(self.es19m20, Market.CME, OptionStyle.American, OptionRight.Call, 3200.0, datetime(2020, 6, 19))
+        ]
+
+        for esOption in self.esOptions:
+            if esOption not in self.expectedContracts:
+                raise AssertionError(f"Contract {esOption} was not found in the chain")
+
+        self.Schedule.On(self.DateRules.Tomorrow, self.TimeRules.AfterMarketOpen(self.es19m20, 1), self.ScheduleCallbackBuy)
+        self.Schedule.On(self.DateRules.Tomorrow, self.TimeRules.Noon, self.ScheduleCallbackLiquidate)
+
+    def ScheduleCallbackBuy(self):
+        self.MarketOrder(self.esOptions[0], 1)
+        self.MarketOrder(self.esOptions[1], -1)
+
+    def ScheduleCallbackLiquidate(self):
+        self.Liquidate()
+
+    def OnEndOfAlgorithm(self):
+        if self.Portfolio.Invested:
+            raise AssertionError(f"Expected no holdings at end of algorithm, but are invested in: {', '.join([str(i.ID) for i in self.Portfolio.Keys])}")
+    

Algorithm.Python/FutureOptionCallITMExpiryRegressionAlgorithm.py

@@ -0,0 +1,133 @@
+# QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+# Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License
+
+from datetime import datetime, timedelta
+
+import clr
+from System import *
+from System.Reflection import *
+from QuantConnect import *
+from QuantConnect.Algorithm import *
+from QuantConnect.Data import *
+from QuantConnect.Data.Market import *
+from QuantConnect.Orders import *
+from QuantConnect.Securities import *
+from QuantConnect.Securities.Future import *
+from QuantConnect import Market
+
+
+### <summary>
+### This regression algorithm tests In The Money (ITM) future option expiry for calls.
+### We expect 3 orders from the algorithm, which are:
+###
+###   * Initial entry, buy ES Call Option (expiring ITM)
+###   * Option exercise, receiving ES future contracts
+###   * Future contract liquidation, due to impending expiry
+###
+### Additionally, we test delistings for future options and assert that our
+### portfolio holdings reflect the orders the algorithm has submitted.
+### </summary>
+class FutureOptionCallITMExpiryRegressionAlgorithm(QCAlgorithm):
+
+    def Initialize(self):
+        self.SetStartDate(2020, 1, 5)
+        self.SetEndDate(2020, 6, 30)
+
+        self.es19m20 = self.AddFutureContract(
+            Symbol.CreateFuture(
+                Futures.Indices.SP500EMini,
+                Market.CME,
+                datetime(2020, 6, 19)
+            ),
+            Resolution.Minute).Symbol
+
+        # Select a future option expiring ITM, and adds it to the algorithm.
+        self.esOption = self.AddFutureOptionContract(
+            list(
+                sorted([x for x in self.OptionChainProvider.GetOptionContractList(self.es19m20, self.Time) if x.ID.StrikePrice <= 3200.0 and x.ID.OptionRight == OptionRight.Call], key=lambda x: x.ID.StrikePrice, reverse=True)
+            )[0], Resolution.Minute).Symbol
+
+        self.expectedContract = Symbol.CreateOption(self.es19m20, Market.CME, OptionStyle.American, OptionRight.Call, 3200.0, datetime(2020, 6, 19))
+        if self.esOption != self.expectedContract:
+            raise AssertionError(f"Contract {self.expectedContract} was not found in the chain")
+
+        self.Schedule.On(self.DateRules.Tomorrow, self.TimeRules.AfterMarketOpen(self.es19m20, 1), self.ScheduleCallback)
+
+    def ScheduleCallback(self):
+        self.MarketOrder(self.esOption, 1)
+
+    def OnData(self, data: Slice):
+        # Assert delistings, so that we can make sure that we receive the delisting warnings at
+        # the expected time. These assertions detect bug #4872
+        for delisting in data.Delistings.Values:
+            if delisting.Type == DelistingType.Warning:
+                if delisting.Time != datetime(2020, 6, 19):
+                    raise AssertionError(f"Delisting warning issued at unexpected date: {delisting.Time}")
+            elif delisting.Type == DelistingType.Delisted:
+                if delisting.Time != datetime(2020, 6, 20):
+                    raise AssertionError(f"Delisting happened at unexpected date: {delisting.Time}")
+
+    def OnOrderEvent(self, orderEvent: OrderEvent):
+        if orderEvent.Status != OrderStatus.Filled:
+            # There's lots of noise with OnOrderEvent, but we're only interested in fills.
+            return
+
+        if not self.Securities.ContainsKey(orderEvent.Symbol):
+            raise AssertionError(f"Order event Symbol not found in Securities collection: {orderEvent.Symbol}")
+
+        security = self.Securities[orderEvent.Symbol]
+        if security.Symbol == self.es19m20:
+            self.AssertFutureOptionOrderExercise(orderEvent, security, self.Securities[self.expectedContract])
+        elif security.Symbol == self.expectedContract:
+            # Expected contract is ES19H21 Call Option expiring ITM @ 3250
+            self.AssertFutureOptionContractOrder(orderEvent, security)
+        else:
+            raise AssertionError(f"Received order event for unknown Symbol: {orderEvent.Symbol}")
+
+        self.Log(f"{self.Time} -- {orderEvent.Symbol} :: Price: {self.Securities[orderEvent.Symbol].Holdings.Price} Qty: {self.Securities[orderEvent.Symbol].Holdings.Quantity} Direction: {orderEvent.Direction} Msg: {orderEvent.Message}")
+
+    def AssertFutureOptionOrderExercise(self, orderEvent: OrderEvent, future: Security, optionContract: Security):
+        expectedLiquidationTimeUtc = datetime(2020, 6, 19, 20, 0, 0)
+
+        if orderEvent.Direction == OrderDirection.Sell and future.Holdings.Quantity != 0:
+            # We expect the contract to have been liquidated immediately
+            raise AssertionError(f"Did not liquidate existing holdings for Symbol {future.Symbol}")
+        if orderEvent.Direction == OrderDirection.Sell and orderEvent.UtcTime.replace(tzinfo=None) != expectedLiquidationTimeUtc:
+            raise AssertionError(f"Liquidated future contract, but not at the expected time. Expected: {expectedLiquidationTimeUtc} - found {orderEvent.UtcTime.replace(tzinfo=None)}");
+
+        # No way to detect option exercise orders or any other kind of special orders
+        # other than matching strings, for now.
+        if "Option Exercise" in orderEvent.Message:
+            if orderEvent.FillPrice != 3200.0:
+                raise AssertionError("Option did not exercise at expected strike price (3200)")
+
+            if future.Holdings.Quantity != 1:
+                # Here, we expect to have some holdings in the underlying, but not in the future option anymore.
+                raise AssertionError(f"Exercised option contract, but we have no holdings for Future {future.Symbol}")
+
+            if optionContract.Holdings.Quantity != 0:
+                raise AssertionError(f"Exercised option contract, but we have holdings for Option contract {optionContract.Symbol}")
+
+    def AssertFutureOptionContractOrder(self, orderEvent: OrderEvent, option: Security):
+        if orderEvent.Direction == OrderDirection.Buy and option.Holdings.Quantity != 1:
+            raise AssertionError(f"No holdings were created for option contract {option.Symbol}")
+
+        if orderEvent.Direction == OrderDirection.Sell and option.Holdings.Quantity != 0:
+            raise AssertionError(f"Holdings were found after a filled option exercise")
+
+        if "Exercise" in orderEvent.Message and option.Holdings.Quantity != 0:
+            raise AssertionError(f"Holdings were found after exercising option contract {option.Symbol}")
+
+    def OnEndOfAlgorithm(self):
+        if self.Portfolio.Invested:
+            raise AssertionError(f"Expected no holdings at end of algorithm, but are invested in: {', '.join([str(i.ID) for i in self.Portfolio.Keys])}")

Algorithm.Python/FutureOptionCallOTMExpiryRegressionAlgorithm.py

@@ -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
+
+from datetime import datetime, timedelta
+
+import clr
+from System import *
+from System.Reflection import *
+from QuantConnect import *
+from QuantConnect.Algorithm import *
+from QuantConnect.Data import *
+from QuantConnect.Data.Market import *
+from QuantConnect.Orders import *
+from QuantConnect.Securities import *
+from QuantConnect.Securities.Future import *
+from QuantConnect import Market
+
+
+### <summary>
+### This regression algorithm tests Out of The Money (OTM) future option expiry for calls.
+### We expect 2 orders from the algorithm, which are:
+###
+###   * Initial entry, buy ES Call Option (expiring OTM)
+###     - contract expires worthless, not exercised, so never opened a position in the underlying
+###
+###   * Liquidation of worthless ES call option (expiring OTM)
+###
+### Additionally, we test delistings for future options and assert that our
+### portfolio holdings reflect the orders the algorithm has submitted.
+### </summary>
+### <remarks>
+### Total Trades in regression algorithm should be 1, but expiration is counted as a trade.
+### See related issue: https://github.com/QuantConnect/Lean/issues/4854
+### </remarks>
+class FutureOptionCallOTMExpiryRegressionAlgorithm(QCAlgorithm):
+    def Initialize(self):
+        self.SetStartDate(2020, 1, 5)
+        self.SetEndDate(2020, 6, 30)
+
+        self.es19m20 = self.AddFutureContract(
+            Symbol.CreateFuture(
+                Futures.Indices.SP500EMini,
+                Market.CME,
+                datetime(2020, 6, 19)),
+            Resolution.Minute).Symbol
+
+        # Select a future option expiring ITM, and adds it to the algorithm.
+        self.esOption = self.AddFutureOptionContract(
+            list(
+                sorted(
+                    [x for x in self.OptionChainProvider.GetOptionContractList(self.es19m20, self.Time) if x.ID.StrikePrice >= 3300.0 and x.ID.OptionRight == OptionRight.Call],
+                    key=lambda x: x.ID.StrikePrice
+                )
+            )[0], Resolution.Minute).Symbol
+
+        self.expectedContract = Symbol.CreateOption(self.es19m20, Market.CME, OptionStyle.American, OptionRight.Call, 3300.0, datetime(2020, 6, 19))
+        if self.esOption != self.expectedContract:
+            raise AssertionError(f"Contract {self.expectedContract} was not found in the chain");
+
+        self.Schedule.On(self.DateRules.Tomorrow, self.TimeRules.AfterMarketOpen(self.es19m20, 1), self.ScheduledMarketOrder)
+
+    def ScheduledMarketOrder(self):
+        self.MarketOrder(self.esOption, 1)
+
+    def OnData(self, data: Slice):
+        # Assert delistings, so that we can make sure that we receive the delisting warnings at
+        # the expected time. These assertions detect bug #4872
+        for delisting in data.Delistings.Values:
+            if delisting.Type == DelistingType.Warning:
+                if delisting.Time != datetime(2020, 6, 19):
+                    raise AssertionError(f"Delisting warning issued at unexpected date: {delisting.Time}");
+
+            if delisting.Type == DelistingType.Delisted:
+                if delisting.Time != datetime(2020, 6, 20):
+                    raise AssertionError(f"Delisting happened at unexpected date: {delisting.Time}");
+        
+
+    def OnOrderEvent(self, orderEvent: OrderEvent):
+        if orderEvent.Status != OrderStatus.Filled:
+            # There's lots of noise with OnOrderEvent, but we're only interested in fills.
+            return
+
+        if not self.Securities.ContainsKey(orderEvent.Symbol):
+            raise AssertionError(f"Order event Symbol not found in Securities collection: {orderEvent.Symbol}")
+
+        security = self.Securities[orderEvent.Symbol]
+        if security.Symbol == self.es19m20:
+            raise AssertionError("Invalid state: did not expect a position for the underlying to be opened, since this contract expires OTM")
+        
+        # Expected contract is ES19M20 Call Option expiring OTM @ 3300
+        if (security.Symbol == self.expectedContract):
+            self.AssertFutureOptionContractOrder(orderEvent, security)
+        else:
+            raise AssertionError(f"Received order event for unknown Symbol: {orderEvent.Symbol}")
+
+        self.Log(f"{orderEvent}");
+        
+
+    def AssertFutureOptionContractOrder(self, orderEvent: OrderEvent, option: Security):
+        if orderEvent.Direction == OrderDirection.Buy and option.Holdings.Quantity != 1:
+            raise AssertionError(f"No holdings were created for option contract {option.Symbol}");
+
+        if orderEvent.Direction == OrderDirection.Sell and option.Holdings.Quantity != 0:
+            raise AssertionError("Holdings were found after a filled option exercise");
+
+        if orderEvent.Direction == OrderDirection.Sell and "OTM" not in orderEvent.Message:
+            raise AssertionError("Contract did not expire OTM");
+
+        if "Exercise" in orderEvent.Message:
+            raise AssertionError("Exercised option, even though it expires OTM");
+
+    def OnEndOfAlgorithm(self):
+        if self.Portfolio.Invested:
+            raise AssertionError(f"Expected no holdings at end of algorithm, but are invested in: {', '.join([str(i.ID) for i in self.Portfolio.Keys])}")

Algorithm.Python/FutureOptionMultipleContractsInDifferentContractMonthsWithSameUnderlyingFutureRegressionAlgorithm.py

@@ -0,0 +1,75 @@
+### QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+### Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+###
+### Licensed under the Apache License, Version 2.0 (the "License");
+### you may not use this file except in compliance with the License.
+### You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+###
+### Unless required by applicable law or agreed to in writing, software
+### distributed under the License is distributed on an "AS IS" BASIS,
+### WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+### See the License for the specific language governing permissions and
+### limitations under the License.
+
+from datetime import datetime
+
+from System import *
+from System.Reflection import *
+import QuantConnect
+from QuantConnect import *
+from QuantConnect.Algorithm import *
+from QuantConnect.Data import *
+from QuantConnect.Data.Market import *
+from QuantConnect.Orders import *
+from QuantConnect.Securities import *
+from QuantConnect.Securities.Future import *
+from QuantConnect import Market
+
+### <summary>
+### This regression test tests for the loading of futures options contracts with a contract month of 2020-03 can live
+### and be loaded from the same ZIP file that the 2020-04 contract month Future Option contract lives in.
+### </summary>
+class FutureOptionMultipleContractsInDifferentContractMonthsWithSameUnderlyingFutureRegressionAlgorithm(QCAlgorithm):
+    def Initialize(self):
+        self.expectedSymbols = {
+            self._createOption(datetime(2020, 3, 26), OptionRight.Call, 1650.0): False,
+            self._createOption(datetime(2020, 3, 26), OptionRight.Put, 1540.0): False,
+            self._createOption(datetime(2020, 2, 25), OptionRight.Call, 1600.0): False,
+            self._createOption(datetime(2020, 2, 25), OptionRight.Put, 1545.0): False
+        }
+
+        self.SetStartDate(2020, 1, 5)
+        self.SetEndDate(2020, 1, 6)
+
+        goldFutures = self.AddFuture("GC", Resolution.Minute, QuantConnect.Market.COMEX)
+        goldFutures.SetFilter(0, 365)
+
+        self.AddFutureOption(goldFutures.Symbol)
+
+    def OnData(self, data: Slice):
+        for symbol in data.QuoteBars.Keys:
+            if symbol in self.expectedSymbols:
+                invested = self.expectedSymbols[symbol]
+                if not invested:
+                    self.MarketOrder(symbol, 1)
+
+                self.expectedSymbols[symbol] = True
+
+    def OnEndOfAlgorithm(self):
+        notEncountered = [str(k) for k,v in self.expectedSymbols.items() if not v]
+        if any(notEncountered):
+            raise AggregateException(f"Expected all Symbols encountered and invested in, but the following were not found: {', '.join(notEncountered)}")
+
+        if not self.Portfolio.Invested:
+            raise AggregateException("Expected holdings at the end of algorithm, but none were found.")
+
+
+    def _createOption(self, expiry: datetime, optionRight: OptionRight, strikePrice: float) -> Symbol:
+        return QuantConnect.Symbol.CreateOption(
+            QuantConnect.Symbol.CreateFuture("GC", QuantConnect.Market.COMEX, datetime(2020, 4, 28)),
+            QuantConnect.Market.COMEX,
+            OptionStyle.American,
+            optionRight,
+            strikePrice,
+            expiry
+        )

Algorithm.Python/FutureOptionPutITMExpiryRegressionAlgorithm.py

@@ -0,0 +1,132 @@
+# QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+# Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License
+
+from datetime import datetime, timedelta
+
+import clr
+from System import *
+from System.Reflection import *
+from QuantConnect import *
+from QuantConnect.Algorithm import *
+from QuantConnect.Data import *
+from QuantConnect.Data.Market import *
+from QuantConnect.Orders import *
+from QuantConnect.Securities import *
+from QuantConnect.Securities.Future import *
+from QuantConnect import Market
+
+
+### <summary>
+### This regression algorithm tests In The Money (ITM) future option expiry for puts.
+### We expect 3 orders from the algorithm, which are:
+###
+###   * Initial entry, buy ES Put Option (expiring ITM) (buy, qty 1)
+###   * Option exercise, receiving short ES future contracts (sell, qty -1)
+###   * Future contract liquidation, due to impending expiry (buy qty 1)
+###
+### Additionally, we test delistings for future options and assert that our
+### portfolio holdings reflect the orders the algorithm has submitted.
+### </summary>
+class FutureOptionPutITMExpiryRegressionAlgorithm(QCAlgorithm):
+    def Initialize(self):
+        self.SetStartDate(2020, 1, 5)
+        self.SetEndDate(2020, 6, 30)
+
+        self.es19m20 = self.AddFutureContract(
+            Symbol.CreateFuture(
+                Futures.Indices.SP500EMini,
+                Market.CME,
+                datetime(2020, 6, 19)
+            ),
+            Resolution.Minute).Symbol
+
+        # Select a future option expiring ITM, and adds it to the algorithm.
+        self.esOption = self.AddFutureOptionContract(
+            list(
+                sorted([x for x in self.OptionChainProvider.GetOptionContractList(self.es19m20, self.Time) if x.ID.StrikePrice >= 3300.0 and x.ID.OptionRight == OptionRight.Put], key=lambda x: x.ID.StrikePrice)
+            )[0], Resolution.Minute).Symbol
+
+        self.expectedContract = Symbol.CreateOption(self.es19m20, Market.CME, OptionStyle.American, OptionRight.Put, 3300.0, datetime(2020, 6, 19))
+        if self.esOption != self.expectedContract:
+            raise AssertionError(f"Contract {self.expectedContract} was not found in the chain")
+
+        self.Schedule.On(self.DateRules.Tomorrow, self.TimeRules.AfterMarketOpen(self.es19m20, 1), self.ScheduleCallback)
+
+    def ScheduleCallback(self):
+        self.MarketOrder(self.esOption, 1)
+
+    def OnData(self, data: Slice):
+        # Assert delistings, so that we can make sure that we receive the delisting warnings at
+        # the expected time. These assertions detect bug #4872
+        for delisting in data.Delistings.Values:
+            if delisting.Type == DelistingType.Warning:
+                if delisting.Time != datetime(2020, 6, 19):
+                    raise AssertionError(f"Delisting warning issued at unexpected date: {delisting.Time}")
+            elif delisting.Type == DelistingType.Delisted:
+                if delisting.Time != datetime(2020, 6, 20):
+                    raise AssertionError(f"Delisting happened at unexpected date: {delisting.Time}")
+
+    def OnOrderEvent(self, orderEvent: OrderEvent):
+        if orderEvent.Status != OrderStatus.Filled:
+            # There's lots of noise with OnOrderEvent, but we're only interested in fills.
+            return
+
+        if not self.Securities.ContainsKey(orderEvent.Symbol):
+            raise AssertionError(f"Order event Symbol not found in Securities collection: {orderEvent.Symbol}")
+
+        security = self.Securities[orderEvent.Symbol]
+        if security.Symbol == self.es19m20:
+            self.AssertFutureOptionOrderExercise(orderEvent, security, self.Securities[self.expectedContract])
+        elif security.Symbol == self.expectedContract:
+            # Expected contract is ES19M20 Call Option expiring ITM @ 3250
+            self.AssertFutureOptionContractOrder(orderEvent, security)
+        else:
+            raise AssertionError(f"Received order event for unknown Symbol: {orderEvent.Symbol}")
+
+        self.Log(f"{self.Time} -- {orderEvent.Symbol} :: Price: {self.Securities[orderEvent.Symbol].Holdings.Price} Qty: {self.Securities[orderEvent.Symbol].Holdings.Quantity} Direction: {orderEvent.Direction} Msg: {orderEvent.Message}")
+
+    def AssertFutureOptionOrderExercise(self, orderEvent: OrderEvent, future: Security, optionContract: Security):
+        expectedLiquidationTimeUtc = datetime(2020, 6, 19, 20, 0, 0)
+
+        if orderEvent.Direction == OrderDirection.Buy and future.Holdings.Quantity != 0:
+            # We expect the contract to have been liquidated immediately
+            raise AssertionError(f"Did not liquidate existing holdings for Symbol {future.Symbol}")
+        if orderEvent.Direction == OrderDirection.Buy and orderEvent.UtcTime.replace(tzinfo=None) != expectedLiquidationTimeUtc:
+            raise AssertionError(f"Liquidated future contract, but not at the expected time. Expected: {expectedLiquidationTimeUtc} - found {orderEvent.UtcTime.replace(tzinfo=None)}");
+
+        # No way to detect option exercise orders or any other kind of special orders
+        # other than matching strings, for now.
+        if "Option Exercise" in orderEvent.Message:
+            if orderEvent.FillPrice != 3300.0:
+                raise AssertionError("Option did not exercise at expected strike price (3300)")
+
+            if future.Holdings.Quantity != -1:
+                # Here, we expect to have some holdings in the underlying, but not in the future option anymore.
+                raise AssertionError(f"Exercised option contract, but we have no holdings for Future {future.Symbol}")
+
+            if optionContract.Holdings.Quantity != 0:
+                raise AssertionError(f"Exercised option contract, but we have holdings for Option contract {optionContract.Symbol}")
+
+    def AssertFutureOptionContractOrder(self, orderEvent: OrderEvent, option: Security):
+        if orderEvent.Direction == OrderDirection.Buy and option.Holdings.Quantity != 1:
+            raise AssertionError(f"No holdings were created for option contract {option.Symbol}")
+
+        if orderEvent.Direction == OrderDirection.Sell and option.Holdings.Quantity != 0:
+            raise AssertionError(f"Holdings were found after a filled option exercise")
+
+        if "Exercise" in orderEvent.Message and option.Holdings.Quantity != 0:
+            raise AssertionError(f"Holdings were found after exercising option contract {option.Symbol}")
+
+    def OnEndOfAlgorithm(self):
+        if self.Portfolio.Invested:
+            raise AssertionError(f"Expected no holdings at end of algorithm, but are invested in: {', '.join([str(i.ID) for i in self.Portfolio.Keys])}")