Solve bug and add unit tests (#7767)

* Add Python version

* Improve implementation

* Improve implementation

.devcontainer/devcontainer.json

@@ -24,7 +24,7 @@
 	// "forwardPorts": [],
 
 	// Uncomment the next line to run commands after the container is created - for example installing curl.
-	"postCreateCommand": "dotnet nuget add source /Lean/LocalPackages; dos2unix /Lean/.vscode/launch_research.sh",
+	"postCreateCommand": "dotnet nuget add source /Lean/LocalPackages;chmod u+x /Lean/.vscode/launch_research.sh;dos2unix /Lean/.vscode/launch_research.sh",
 
 	// Add mounts to docker container
 	"mounts": [ 

.github/workflows/api-tests.yml

@@ -0,0 +1,30 @@
+name: API Tests
+
+on:
+  push:
+    branches: ['*']
+    tags: ['*']
+  pull_request:
+    branches: [master]
+
+jobs:
+  build:
+    runs-on: ubuntu-20.04
+    # Only run on push events (not on pull_request) for security reasons in order to be able to use secrets
+    if: ${{ github.event_name == 'push' }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Free space
+        run: df -h && rm -rf /opt/hostedtoolcache* && df -h
+      - name: Run API Tests
+        uses: addnab/docker-run-action@v3
+        with:
+          image: quantconnect/lean:foundation
+          options: --workdir /__w/Lean/Lean -v /home/runner/work:/__w -e GITHUB_REF=${{ github.ref }} -e QC_JOB_USER_ID=${{ secrets.QC_JOB_USER_ID }} -e QC_API_ACCESS_TOKEN=${{ secrets.QC_API_ACCESS_TOKEN }} -e QC_JOB_ORGANIZATION_ID=${{ secrets.QC_JOB_ORGANIZATION_ID }}
+          shell: bash
+          run: |
+            # Build
+            dotnet build /p:Configuration=Release /v:quiet /p:WarningLevel=1 QuantConnect.Lean.sln
+            # Run Projects tests
+            dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --blame-hang-timeout 300seconds --blame-crash --filter "FullyQualifiedName=QuantConnect.Tests.API.ProjectTests" -- TestRunParameters.Parameter\(name=\"log-handler\", value=\"ConsoleErrorLogHandler\"\)

.github/workflows/gh-actions.yml

@@ -10,23 +10,21 @@ on:
 jobs:
   build:
     runs-on: ubuntu-20.04
-    container:
-        image: quantconnect/lean:foundation
     steps:
-      - uses: actions/checkout@v2
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Free space
+        run: df -h && rm -rf /opt/hostedtoolcache* && df -h
 
-      - name: Build
-        run: dotnet build /p:Configuration=Release /v:quiet /p:WarningLevel=1 QuantConnect.Lean.sln
-
-      - name: Run Tests
-        run: dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "TestCategory!=TravisExclude&TestCategory!=ResearchRegressionTests" -- TestRunParameters.Parameter\(name=\"log-handler\", value=\"ConsoleErrorLogHandler\"\)
-
-      - name: Generate & Publish python stubs
-        if: startsWith(github.ref, 'refs/tags/')
-        run: |
-          chmod +x ci_build_stubs.sh
-          ./ci_build_stubs.sh -t -g -p
-        env:
-          PYPI_API_TOKEN: ${{ secrets.PYPI_API_TOKEN }}
-          ADDITIONAL_STUBS_REPOS: ${{ secrets.ADDITIONAL_STUBS_REPOS }}
-          QC_GIT_TOKEN: ${{ secrets.QC_GIT_TOKEN }}
+      - uses: addnab/docker-run-action@v3
+        with:
+          image: quantconnect/lean:foundation
+          options: --workdir /__w/Lean/Lean -v /home/runner/work:/__w -e GITHUB_REF=${{ github.ref }} -e PYPI_API_TOKEN=${{ secrets.PYPI_API_TOKEN }} -e ADDITIONAL_STUBS_REPOS=${{ secrets.ADDITIONAL_STUBS_REPOS }} -e QC_GIT_TOKEN=${{ secrets.QC_GIT_TOKEN }}
+          shell: bash
+          run: |
+            # Build
+            dotnet build /p:Configuration=Release /v:quiet /p:WarningLevel=1 QuantConnect.Lean.sln && \
+            # Run Tests
+            dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --blame-hang-timeout 300seconds --blame-crash --filter "TestCategory!=TravisExclude&TestCategory!=ResearchRegressionTests" -- TestRunParameters.Parameter\(name=\"log-handler\", value=\"ConsoleErrorLogHandler\"\) && \
+            # Generate & Publish python stubs
+            echo "GITHUB_REF $GITHUB_REF" && if [[ $GITHUB_REF = refs/tags/* ]]; then (chmod +x ci_build_stubs.sh && ./ci_build_stubs.sh -t -g -p); else echo "Skipping stub generation"; fi

.github/workflows/regression-tests.yml

@@ -10,13 +10,19 @@ on:
 jobs:
   build:
     runs-on: ubuntu-20.04
-    container:
-        image: quantconnect/lean:foundation
     steps:
-      - uses: actions/checkout@v2
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Free space
+        run: df -h && rm -rf /opt/hostedtoolcache* && df -h
 
-      - name: Build
-        run: dotnet build /p:Configuration=Release /v:quiet /p:WarningLevel=1 QuantConnect.Lean.sln
-
-      - name: Run Tests
-        run: dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter TestCategory=RegressionTests -- TestRunParameters.Parameter\(name=\"log-handler\", value=\"ConsoleErrorLogHandler\"\) TestRunParameters.Parameter\(name=\"reduced-disk-size\", value=\"true\"\)
+      - uses: addnab/docker-run-action@v3
+        with:
+          image: quantconnect/lean:foundation
+          options: --workdir /__w/Lean/Lean -v /home/runner/work:/__w
+          shell: bash
+          run: |
+            # Build
+            dotnet build /p:Configuration=Release /v:quiet /p:WarningLevel=1 QuantConnect.Lean.sln
+            # Run Tests
+            dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter TestCategory=RegressionTests -- TestRunParameters.Parameter\(name=\"log-handler\", value=\"ConsoleErrorLogHandler\"\) TestRunParameters.Parameter\(name=\"reduced-disk-size\", value=\"true\"\)

.github/workflows/research-regression-tests.yml

@@ -10,26 +10,27 @@ on:
 jobs:
   build:
     runs-on: ubuntu-20.04
-    container:
-        image: quantconnect/lean:foundation
     steps:
-      - uses: actions/checkout@v2
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Free space
+        run: df -h && rm -rf /opt/hostedtoolcache* && df -h
 
-      - name: install dependencies
-        run: |
-          pip3 install papermill==2.4.0 clr-loader==0.1.6
-
-      - name: install kernel
-        run: dotnet tool install --global Microsoft.dotnet-interactive --version 1.0.340501
-
-      - name: Add dotnet tools to Path
-        run: echo "$HOME/.dotnet/tools" >> $GITHUB_PATH
-
-      - name: activate kernel for jupyter
-        run: dotnet interactive jupyter install
-
-      - name: Build
-        run: dotnet build /p:Configuration=Release /v:quiet /p:WarningLevel=1 QuantConnect.Lean.sln
-
-      - name: Run Tests
-        run: dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter TestCategory=ResearchRegressionTests -- TestRunParameters.Parameter\(name=\"log-handler\", value=\"ConsoleErrorLogHandler\"\) TestRunParameters.Parameter\(name=\"reduced-disk-size\", value=\"true\"\)
+      - uses: addnab/docker-run-action@v3
+        with:
+          image: quantconnect/lean:foundation
+          options: --workdir /__w/Lean/Lean -v /home/runner/work:/__w
+          shell: bash
+          run: |
+            # install dependencies
+            pip3 install papermill==2.4.0 clr-loader==0.1.6
+            # install kernel
+            dotnet tool install --global Microsoft.dotnet-interactive --version 1.0.340501
+            # Add dotnet tools to Path
+            export PATH="$HOME/.dotnet/tools:$PATH"
+            # activate kernel for jupyter
+            dotnet interactive jupyter install
+            # Build
+            dotnet build /p:Configuration=Release /v:quiet /p:WarningLevel=1 QuantConnect.Lean.sln
+            # Run Tests
+            dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter TestCategory=ResearchRegressionTests -- TestRunParameters.Parameter\(name=\"log-handler\", value=\"ConsoleErrorLogHandler\"\) TestRunParameters.Parameter\(name=\"reduced-disk-size\", value=\"true\"\)

.github/workflows/virtual-environments.yml

@@ -10,52 +10,49 @@ on:
 jobs:
   build:
     runs-on: ubuntu-20.04
-    container:
-        image: quantconnect/lean:foundation
     steps:
-      - uses: actions/checkout@v2
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Free space
+        run: df -h && rm -rf /opt/hostedtoolcache* && df -h
 
-      - name: Build
-        run: dotnet build /p:Configuration=Release /v:quiet /p:WarningLevel=1 QuantConnect.Lean.sln
-
-      - name: Python Virtual Environment System Packages
-        run: python -m venv /lean-testenv --system-site-packages && . /lean-testenv/bin/activate && pip install --no-cache-dir lean==1.0.99 && deactivate
-
-      - name: Run Virtual Environment Test System Packages
-        run: dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonVirtualEnvironmentTests.AssertVirtualEnvironment"
-
-      - name: Python Virtual Environment
-        run: rm -rf /lean-testenv && python -m venv /lean-testenv && . /lean-testenv/bin/activate && pip install --no-cache-dir lean==1.0.99 && deactivate
-
-      - name: Run Virtual Environment Test
-        run: dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonVirtualEnvironmentTests.AssertVirtualEnvironment"
-
-      - name: Run Python Package Tests
-        run: dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests"
-
-      - name: Run Pomegranate Python Package Test
-        run: dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests.PomegranateTest"
-
-      - name: Run Tensorforce Python Package Test
-        run: dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests.TensorforceTests"
-
-      - name: Run StableBaselines Python Package Test
-        run: dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests.StableBaselinesTest"
-
-      - name: Run AxPlatform Python Package Test
-        run: dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests.AxPlatformTest"
-
-      - name: Run NeuralTangents Python Package Test
-        run: dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests.NeuralTangentsTest"
-
-      - name: Run NBeats Python Package Test
-        run: dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests.NBeatsTest"
-
-      - name: Run Tensorly Python Package Test
-        run: dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests.TensorlyTest"
-
-      - name: Run Ignite Python Package Test
-        run: dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests.IgniteTest"
-
-      - name: Run Hvplot Python Package Test
-        run: dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests.HvplotTest"
+      - uses: addnab/docker-run-action@v3
+        with:
+          image: quantconnect/lean:foundation
+          options: --workdir /__w/Lean/Lean -v /home/runner/work:/__w
+          shell: bash
+          run: |
+            # Build
+            dotnet build /p:Configuration=Release /v:quiet /p:WarningLevel=1 QuantConnect.Lean.sln
+            # Python Virtual Environment System Packages
+            python -m venv /lean-testenv --system-site-packages && . /lean-testenv/bin/activate && pip install --no-cache-dir lean==1.0.99 && deactivate
+            # Run Virtual Environment Test System Packages
+            dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonVirtualEnvironmentTests.AssertVirtualEnvironment"
+            # Python Virtual Environment
+            rm -rf /lean-testenv && python -m venv /lean-testenv && . /lean-testenv/bin/activate && pip install --no-cache-dir lean==1.0.99 && deactivate
+            # Run Virtual Environment Test
+            dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonVirtualEnvironmentTests.AssertVirtualEnvironment"
+            # Run Python Package Tests
+            dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests" --blame-hang-timeout 120seconds --blame-crash
+            # Run StableBaselines Python Package Test
+            dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests.StableBaselinesTest" --blame-hang-timeout 120seconds --blame-crash
+            # Run AxPlatform Python Package Test
+            dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests.AxPlatformTest" --blame-hang-timeout 120seconds --blame-crash
+            # Run TensorlyTest Python Package Test
+            dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests.TensorlyTest" --blame-hang-timeout 120seconds --blame-crash
+            # Run NeuralTangents, Ignite Python Package Test
+            dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests.NeuralTangentsTest|IgniteTest" --blame-hang-timeout 120seconds --blame-crash
+            # Run TensorflowTest
+            dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests.TensorflowTest" --blame-hang-timeout 120seconds --blame-crash
+            # Run TensorflowProbability
+            dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests.TensorflowProbabilityTest" --blame-hang-timeout 120seconds --blame-crash
+            # Run Hvplot Python Package Test
+            dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests.HvplotTest" --blame-hang-timeout 120seconds --blame-crash
+            # Run Stellargraph Python Package Test
+            dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests.StellargraphTest" --blame-hang-timeout 120seconds --blame-crash
+            # Run Keras Python Package Test
+            dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests.KerasTest" --blame-hang-timeout 120seconds --blame-crash
+            # Run Scikeras Python Package Test
+            dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests.ScikerasTest" --blame-hang-timeout 120seconds --blame-crash
+            # Run Transformers
+            dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests.Transformers|XTransformers" --blame-hang-timeout 120seconds --blame-crash

.gitignore

@@ -1,3 +1,6 @@
+# OS Files
+.DS_Store
+
 # Object files
 *.o
 *.ko

.vs/readme.md

@@ -20,8 +20,8 @@ To use Lean CLI follow the instructions for installation and tutorial for usage
 
 1. Install [.Net 6](https://dotnet.microsoft.com/download) for the project
 
-2. (Optional) Get [Python 3.6.8](https://www.python.org/downloads/release/python-368/) for running Python algorithms
-    - Follow Python instructions [here](https://github.com/QuantConnect/Lean/tree/master/Algorithm.Python#installing-python-36) for your platform
+2. (Optional) Get [Python 3.8.13](https://www.python.org/downloads/release/python-3813/) for running Python algorithms
+    - Follow Python instructions [here](https://github.com/QuantConnect/Lean/tree/master/Algorithm.Python#installing-python-38) for your platform
 
 3. Get [Visual Studio](https://visualstudio.microsoft.com/vs/)
 

.vscode/readme.md

@@ -156,5 +156,5 @@ _Figure 2: Python Debugger Messages_
 Here we will cover some common issues with setting this up. This section will expand as we get user feedback!
 
 - The "project file cannot be loaded" and "nuget packages not found" errors occurs when the project files are open by another process in the host. Closing all applications and/or restarting the computer solve the issue.
-- Autocomplete and reference finding with omnisharp can sometimes bug, if this occurs use the command palette to restart omnisharp. (Ctrl+Shift+P "OmniSharp: Restart OmniSharp")
+- Autocomplete and reference finding with omnisharp can sometimes be buggy, if this occurs use the command palette to restart omnisharp. (Ctrl+Shift+P "OmniSharp: Restart OmniSharp")
 - 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.

Algorithm.CSharp/AccumulativeInsightPortfolioRegressionAlgorithm.cs

@@ -91,41 +91,24 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "0.200%"},
             {"Expectancy", "-0.585"},
             {"Net Profit", "-0.172%"},
-            {"Sharpe Ratio", "-10.169"},
+            {"Sharpe Ratio", "-11.13"},
+            {"Sortino Ratio", "-16.704"},
             {"Probabilistic Sharpe Ratio", "12.075%"},
             {"Loss Rate", "78%"},
             {"Win Rate", "22%"},
             {"Profit-Loss Ratio", "0.87"},
-            {"Alpha", "-0.149"},
+            {"Alpha", "-0.156"},
             {"Beta", "0.035"},
             {"Annual Standard Deviation", "0.008"},
             {"Annual Variance", "0"},
             {"Information Ratio", "-9.603"},
             {"Tracking Error", "0.215"},
-            {"Treynor Ratio", "-2.264"},
+            {"Treynor Ratio", "-2.478"},
             {"Total Fees", "$199.00"},
             {"Estimated Strategy Capacity", "$26000000.00"},
             {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
-            {"Fitness Score", "0.002"},
-            {"Kelly Criterion Estimate", "38.796"},
-            {"Kelly Criterion Probability Value", "0.228"},
-            {"Sortino Ratio", "-22.493"},
-            {"Return Over Maximum Drawdown", "-77.93"},
-            {"Portfolio Turnover", "1.211"},
-            {"Total Insights Generated", "100"},
-            {"Total Insights Closed", "99"},
-            {"Total Insights Analysis Completed", "99"},
-            {"Long Insight Count", "100"},
-            {"Short Insight Count", "0"},
-            {"Long/Short Ratio", "100%"},
-            {"Estimated Monthly Alpha Value", "$135639.1761"},
-            {"Total Accumulated Estimated Alpha Value", "$21852.9784"},
-            {"Mean Population Estimated Insight Value", "$220.7372"},
-            {"Mean Population Direction", "53.5354%"},
-            {"Mean Population Magnitude", "53.5354%"},
-            {"Rolling Averaged Population Direction", "58.2788%"},
-            {"Rolling Averaged Population Magnitude", "58.2788%"},
-            {"OrderListHash", "3c4c4085810cc5ecdb927d3647b9bbf3"}
+            {"Portfolio Turnover", "119.89%"},
+            {"OrderListHash", "2b4c6d1cb2fc32e25f9a744e8aa7229a"}
         };
     }
 }

Algorithm.CSharp/AddAlphaModelAlgorithm.cs

@@ -127,41 +127,24 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "1.700%"},
             {"Expectancy", "1.781"},
             {"Net Profit", "1.442%"},
-            {"Sharpe Ratio", "4.86"},
+            {"Sharpe Ratio", "4.836"},
+            {"Sortino Ratio", "10.481"},
             {"Probabilistic Sharpe Ratio", "59.497%"},
             {"Loss Rate", "33%"},
             {"Win Rate", "67%"},
             {"Profit-Loss Ratio", "3.17"},
-            {"Alpha", "4.181"},
+            {"Alpha", "4.164"},
             {"Beta", "-1.322"},
             {"Annual Standard Deviation", "0.321"},
             {"Annual Variance", "0.103"},
             {"Information Ratio", "-0.795"},
             {"Tracking Error", "0.532"},
-            {"Treynor Ratio", "-1.18"},
+            {"Treynor Ratio", "-1.174"},
             {"Total Fees", "$14.78"},
             {"Estimated Strategy Capacity", "$47000000.00"},
             {"Lowest Capacity Asset", "IBM R735QTJ8XC9X"},
-            {"Fitness Score", "0.408"},
-            {"Kelly Criterion Estimate", "16.559"},
-            {"Kelly Criterion Probability Value", "0.316"},
-            {"Sortino Ratio", "12.447"},
-            {"Return Over Maximum Drawdown", "106.327"},
-            {"Portfolio Turnover", "0.411"},
-            {"Total Insights Generated", "3"},
-            {"Total Insights Closed", "3"},
-            {"Total Insights Analysis Completed", "3"},
-            {"Long Insight Count", "0"},
-            {"Short Insight Count", "3"},
-            {"Long/Short Ratio", "0%"},
-            {"Estimated Monthly Alpha Value", "$20784418.6104"},
-            {"Total Accumulated Estimated Alpha Value", "$3579538.7607"},
-            {"Mean Population Estimated Insight Value", "$1193179.5869"},
-            {"Mean Population Direction", "100%"},
-            {"Mean Population Magnitude", "0%"},
-            {"Rolling Averaged Population Direction", "100%"},
-            {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "9da9afe1e9137638a55db1676adc2be1"}
+            {"Portfolio Turnover", "41.18%"},
+            {"OrderListHash", "e07dec6ddf0ef6b5d9c791b0593ec4dc"}
         };
     }
 }

Algorithm.CSharp/AddAndRemoveOptionContractRegressionAlgorithm.cs

@@ -105,6 +105,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Expectancy", "0"},
             {"Net Profit", "0%"},
             {"Sharpe Ratio", "0"},
+            {"Sortino Ratio", "0"},
             {"Probabilistic Sharpe Ratio", "0%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
@@ -119,25 +120,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Fees", "$0.00"},
             {"Estimated Strategy Capacity", "$0"},
             {"Lowest Capacity Asset", ""},
-            {"Fitness Score", "0"},
-            {"Kelly Criterion Estimate", "0"},
-            {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "79228162514264337593543950335"},
-            {"Portfolio Turnover", "0"},
-            {"Total Insights Generated", "0"},
-            {"Total Insights Closed", "0"},
-            {"Total Insights Analysis Completed", "0"},
-            {"Long Insight Count", "0"},
-            {"Short Insight Count", "0"},
-            {"Long/Short Ratio", "100%"},
-            {"Estimated Monthly Alpha Value", "$0"},
-            {"Total Accumulated Estimated Alpha Value", "$0"},
-            {"Mean Population Estimated Insight Value", "$0"},
-            {"Mean Population Direction", "0%"},
-            {"Mean Population Magnitude", "0%"},
-            {"Rolling Averaged Population Direction", "0%"},
-            {"Rolling Averaged Population Magnitude", "0%"},
+            {"Portfolio Turnover", "0%"},
             {"OrderListHash", "d41d8cd98f00b204e9800998ecf8427e"}
         };
     }

Algorithm.CSharp/AddAndRemoveSecuritySameLoopRegressionAlgorithm.cs

@@ -102,6 +102,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Expectancy", "0"},
             {"Net Profit", "0%"},
             {"Sharpe Ratio", "0"},
+            {"Sortino Ratio", "0"},
             {"Probabilistic Sharpe Ratio", "0%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
@@ -116,25 +117,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Fees", "$0.00"},
             {"Estimated Strategy Capacity", "$0"},
             {"Lowest Capacity Asset", ""},
-            {"Fitness Score", "0"},
-            {"Kelly Criterion Estimate", "0"},
-            {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "79228162514264337593543950335"},
-            {"Portfolio Turnover", "0"},
-            {"Total Insights Generated", "0"},
-            {"Total Insights Closed", "0"},
-            {"Total Insights Analysis Completed", "0"},
-            {"Long Insight Count", "0"},
-            {"Short Insight Count", "0"},
-            {"Long/Short Ratio", "100%"},
-            {"Estimated Monthly Alpha Value", "$0"},
-            {"Total Accumulated Estimated Alpha Value", "$0"},
-            {"Mean Population Estimated Insight Value", "$0"},
-            {"Mean Population Direction", "0%"},
-            {"Mean Population Magnitude", "0%"},
-            {"Rolling Averaged Population Direction", "0%"},
-            {"Rolling Averaged Population Magnitude", "0%"},
+            {"Portfolio Turnover", "0%"},
             {"OrderListHash", "d41d8cd98f00b204e9800998ecf8427e"}
         };
     }

Algorithm.CSharp/AddBetaIndicatorRegressionAlgorithm.cs

@@ -121,41 +121,24 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "0.300%"},
             {"Expectancy", "0"},
             {"Net Profit", "0.289%"},
-            {"Sharpe Ratio", "4.233"},
+            {"Sharpe Ratio", "3.924"},
+            {"Sortino Ratio", "0"},
             {"Probabilistic Sharpe Ratio", "68.349%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "0.035"},
+            {"Alpha", "0.028"},
             {"Beta", "0.122"},
             {"Annual Standard Deviation", "0.024"},
             {"Annual Variance", "0.001"},
             {"Information Ratio", "-3.181"},
             {"Tracking Error", "0.142"},
-            {"Treynor Ratio", "0.842"},
+            {"Treynor Ratio", "0.78"},
             {"Total Fees", "$1.00"},
             {"Estimated Strategy Capacity", "$35000000.00"},
             {"Lowest Capacity Asset", "IBM R735QTJ8XC9X"},
-            {"Fitness Score", "0.022"},
-            {"Kelly Criterion Estimate", "0"},
-            {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "8.508"},
-            {"Return Over Maximum Drawdown", "58.894"},
-            {"Portfolio Turnover", "0.022"},
-            {"Total Insights Generated", "0"},
-            {"Total Insights Closed", "0"},
-            {"Total Insights Analysis Completed", "0"},
-            {"Long Insight Count", "0"},
-            {"Short Insight Count", "0"},
-            {"Long/Short Ratio", "100%"},
-            {"Estimated Monthly Alpha Value", "$0"},
-            {"Total Accumulated Estimated Alpha Value", "$0"},
-            {"Mean Population Estimated Insight Value", "$0"},
-            {"Mean Population Direction", "0%"},
-            {"Mean Population Magnitude", "0%"},
-            {"Rolling Averaged Population Direction", "0%"},
-            {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "bd88c6a0e10c7e146b05377205101a12"}
+            {"Portfolio Turnover", "1.51%"},
+            {"OrderListHash", "381bb9310f9dceb8a79a56849789bdab"}
         };
     }
 }

Algorithm.CSharp/AddFutureContractWithContinuousRegressionAlgorithm.cs

@@ -135,41 +135,24 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "0.000%"},
             {"Expectancy", "-1"},
             {"Net Profit", "-0.034%"},
-            {"Sharpe Ratio", "-7.854"},
+            {"Sharpe Ratio", "-10.666"},
+            {"Sortino Ratio", "0"},
             {"Probabilistic Sharpe Ratio", "1.216%"},
             {"Loss Rate", "100%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "-0.022"},
+            {"Alpha", "-0.029"},
             {"Beta", "0.004"},
             {"Annual Standard Deviation", "0.003"},
             {"Annual Variance", "0"},
             {"Information Ratio", "-0.768"},
             {"Tracking Error", "0.241"},
-            {"Treynor Ratio", "-4.689"},
+            {"Treynor Ratio", "-6.368"},
             {"Total Fees", "$8.60"},
             {"Estimated Strategy Capacity", "$5500000.00"},
             {"Lowest Capacity Asset", "ES VMKLFZIH2MTD"},
-            {"Fitness Score", "0.417"},
-            {"Kelly Criterion Estimate", "0"},
-            {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "-81.518"},
-            {"Portfolio Turnover", "0.834"},
-            {"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", "802a335b5c355e83b8cd2174f053c1b9"}
+            {"Portfolio Turnover", "66.80%"},
+            {"OrderListHash", "0ade3a7a7aaafa3263082c93cf17c4d8"}
         };
     }
 }

Algorithm.CSharp/AddFutureOptionContractDataStreamingRegressionAlgorithm.cs

@@ -183,41 +183,24 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "1.000%"},
             {"Expectancy", "0"},
             {"Net Profit", "5.333%"},
-            {"Sharpe Ratio", "64.137"},
+            {"Sharpe Ratio", "64.084"},
+            {"Sortino Ratio", "0"},
             {"Probabilistic Sharpe Ratio", "95.977%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "25.72"},
+            {"Alpha", "25.763"},
             {"Beta", "2.914"},
             {"Annual Standard Deviation", "0.423"},
             {"Annual Variance", "0.179"},
             {"Information Ratio", "66.11"},
             {"Tracking Error", "0.403"},
-            {"Treynor Ratio", "9.315"},
+            {"Treynor Ratio", "9.308"},
             {"Total Fees", "$8.60"},
             {"Estimated Strategy Capacity", "$22000000.00"},
             {"Lowest Capacity Asset", "ES XFH59UK0MYO1"},
-            {"Fitness Score", "1"},
-            {"Kelly Criterion Estimate", "0"},
-            {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "79228162514264337593543950335"},
-            {"Portfolio Turnover", "2.035"},
-            {"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", "e7021bd385f366771ae00abd3a46a22e"}
+            {"Portfolio Turnover", "122.11%"},
+            {"OrderListHash", "679692e30a7cf3b54b09af766589df80"}
         };
     }
 }

Algorithm.CSharp/AddFutureOptionContractFromFutureChainRegressionAlgorithm.cs

@@ -112,12 +112,13 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "5.200%"},
             {"Expectancy", "0"},
             {"Net Profit", "11.912%"},
-            {"Sharpe Ratio", "1604181.92"},
+            {"Sharpe Ratio", "1604181.904"},
+            {"Sortino Ratio", "0"},
             {"Probabilistic Sharpe Ratio", "0%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "2144881.34"},
+            {"Alpha", "2144882.02"},
             {"Beta", "31.223"},
             {"Annual Standard Deviation", "1.337"},
             {"Annual Variance", "1.788"},
@@ -127,26 +128,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Fees", "$35.70"},
             {"Estimated Strategy Capacity", "$2600000.00"},
             {"Lowest Capacity Asset", "ES 31C3JQS9D84PW|ES XCZJLC9NOB29"},
-            {"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", "64221a660525c4259d5bd852eef1299c"}
+            {"Portfolio Turnover", "495.15%"},
+            {"OrderListHash", "39179b5e977b8bf5411fbd31896a7953"}
         };
     }
 }

Algorithm.CSharp/AddFutureOptionSingleOptionChainSelectedInUniverseFilterRegressionAlgorithm.cs

@@ -220,7 +220,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 608437;
+        public long DataPoints => 608372;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -239,41 +239,24 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "0.900%"},
             {"Expectancy", "0"},
             {"Net Profit", "1.951%"},
-            {"Sharpe Ratio", "15.548"},
+            {"Sharpe Ratio", "15.402"},
+            {"Sortino Ratio", "0"},
             {"Probabilistic Sharpe Ratio", "95.977%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "1.885"},
+            {"Alpha", "1.886"},
             {"Beta", "1.066"},
             {"Annual Standard Deviation", "0.155"},
             {"Annual Variance", "0.024"},
             {"Information Ratio", "13.528"},
             {"Tracking Error", "0.142"},
-            {"Treynor Ratio", "2.258"},
+            {"Treynor Ratio", "2.237"},
             {"Total Fees", "$3.57"},
             {"Estimated Strategy Capacity", "$760000.00"},
             {"Lowest Capacity Asset", "ES XCZJLDQX2SRO|ES XCZJLC9NOB29"},
-            {"Fitness Score", "0.403"},
-            {"Kelly Criterion Estimate", "0"},
-            {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "79228162514264337593543950335"},
-            {"Portfolio Turnover", "0.403"},
-            {"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", "738240babf741f1bf79f85ea5026ec4c"}
+            {"Portfolio Turnover", "32.31%"},
+            {"OrderListHash", "b508146aff4ac449e9c6f502928e2115"}
         };
     }
 }

Algorithm.CSharp/AddOptionContractExpiresRegressionAlgorithm.cs

@@ -136,41 +136,24 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "0.300%"},
             {"Expectancy", "-0.042"},
             {"Net Profit", "-0.332%"},
-            {"Sharpe Ratio", "-3.149"},
+            {"Sharpe Ratio", "-4.614"},
+            {"Sortino Ratio", "0"},
             {"Probabilistic Sharpe Ratio", "0.427%"},
             {"Loss Rate", "50%"},
             {"Win Rate", "50%"},
             {"Profit-Loss Ratio", "0.92"},
-            {"Alpha", "-0.015"},
+            {"Alpha", "-0.022"},
             {"Beta", "-0.012"},
             {"Annual Standard Deviation", "0.005"},
             {"Annual Variance", "0"},
             {"Information Ratio", "-2.823"},
             {"Tracking Error", "0.049"},
-            {"Treynor Ratio", "1.372"},
+            {"Treynor Ratio", "2.01"},
             {"Total Fees", "$2.00"},
-            {"Estimated Strategy Capacity", "$67000000.00"},
+            {"Estimated Strategy Capacity", "$5700000.00"},
             {"Lowest Capacity Asset", "AOL VRKS95ENLBYE|AOL R735QTJ8XC9X"},
-            {"Fitness Score", "0"},
-            {"Kelly Criterion Estimate", "0"},
-            {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "-43.418"},
-            {"Return Over Maximum Drawdown", "-14.274"},
-            {"Portfolio Turnover", "0.007"},
-            {"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", "4f50b8360ea317ef974801649088bd06"}
+            {"Portfolio Turnover", "0.55%"},
+            {"OrderListHash", "402c66beb5c96b2f2ae357c49e890dc5"}
         };
     }
 }

Algorithm.CSharp/AddOptionContractFromUniverseRegressionAlgorithm.cs

@@ -169,7 +169,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 5797;
+        public long DataPoints => 5798;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -188,41 +188,24 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "0.200%"},
             {"Expectancy", "-1"},
             {"Net Profit", "-0.232%"},
-            {"Sharpe Ratio", "-7.739"},
+            {"Sharpe Ratio", "-8.903"},
+            {"Sortino Ratio", "0"},
             {"Probabilistic Sharpe Ratio", "1.216%"},
             {"Loss Rate", "100%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "0.024"},
+            {"Alpha", "0.015"},
             {"Beta", "-0.171"},
             {"Annual Standard Deviation", "0.006"},
             {"Annual Variance", "0"},
             {"Information Ratio", "-11.082"},
             {"Tracking Error", "0.043"},
-            {"Treynor Ratio", "0.291"},
+            {"Treynor Ratio", "0.335"},
             {"Total Fees", "$2.00"},
             {"Estimated Strategy Capacity", "$2800000.00"},
             {"Lowest Capacity Asset", "AOL VRKS95ENLBYE|AOL R735QTJ8XC9X"},
-            {"Fitness Score", "0"},
-            {"Kelly Criterion Estimate", "0"},
-            {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "-19.883"},
-            {"Return Over Maximum Drawdown", "-67.224"},
-            {"Portfolio Turnover", "0.014"},
-            {"Total Insights Generated", "0"},
-            {"Total Insights Closed", "0"},
-            {"Total Insights Analysis Completed", "0"},
-            {"Long Insight Count", "0"},
-            {"Short Insight Count", "0"},
-            {"Long/Short Ratio", "100%"},
-            {"Estimated Monthly Alpha Value", "$0"},
-            {"Total Accumulated Estimated Alpha Value", "$0"},
-            {"Mean Population Estimated Insight Value", "$0"},
-            {"Mean Population Direction", "0%"},
-            {"Mean Population Magnitude", "0%"},
-            {"Rolling Averaged Population Direction", "0%"},
-            {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "ae0b430e9c728966e3736fb352a689c6"}
+            {"Portfolio Turnover", "1.14%"},
+            {"OrderListHash", "99fd501dbd9e78656be9b32869fc32e0"}
         };
     }
 }

Algorithm.CSharp/AddOptionContractTwiceRegressionAlgorithm.cs

@@ -136,6 +136,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Expectancy", "-1"},
             {"Net Profit", "-0.051%"},
             {"Sharpe Ratio", "0"},
+            {"Sortino Ratio", "0"},
             {"Probabilistic Sharpe Ratio", "0%"},
             {"Loss Rate", "100%"},
             {"Win Rate", "0%"},
@@ -150,26 +151,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Fees", "$2.00"},
             {"Estimated Strategy Capacity", "$30000.00"},
             {"Lowest Capacity Asset", "AAPL VXBK4Q9ZIFD2|AAPL R735QTJ8XC9X"},
-            {"Fitness Score", "0"},
-            {"Kelly Criterion Estimate", "0"},
-            {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "-89.181"},
-            {"Portfolio Turnover", "0"},
-            {"Total Insights Generated", "0"},
-            {"Total Insights Closed", "0"},
-            {"Total Insights Analysis Completed", "0"},
-            {"Long Insight Count", "0"},
-            {"Short Insight Count", "0"},
-            {"Long/Short Ratio", "100%"},
-            {"Estimated Monthly Alpha Value", "$0"},
-            {"Total Accumulated Estimated Alpha Value", "$0"},
-            {"Mean Population Estimated Insight Value", "$0"},
-            {"Mean Population Direction", "0%"},
-            {"Mean Population Magnitude", "0%"},
-            {"Rolling Averaged Population Direction", "0%"},
-            {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "546b6182e1df2d222178454d8f311566"}
+            {"Portfolio Turnover", "0.07%"},
+            {"OrderListHash", "b01a993665c5333c37de9dbef0717e14"}
         };
     }
 }

Algorithm.CSharp/AddOptionWithOnMarketOpenOnlyFilterRegressionAlgorithm.cs

@@ -88,7 +88,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all time slices of algorithm
         /// </summary>
-        public long DataPoints => 3338420;
+        public long DataPoints => 5952220;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -108,6 +108,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Expectancy", "0"},
             {"Net Profit", "0%"},
             {"Sharpe Ratio", "0"},
+            {"Sortino Ratio", "0"},
             {"Probabilistic Sharpe Ratio", "0%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
@@ -122,25 +123,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Fees", "$0.00"},
             {"Estimated Strategy Capacity", "$0"},
             {"Lowest Capacity Asset", ""},
-            {"Fitness Score", "0"},
-            {"Kelly Criterion Estimate", "0"},
-            {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "79228162514264337593543950335"},
-            {"Portfolio Turnover", "0"},
-            {"Total Insights Generated", "0"},
-            {"Total Insights Closed", "0"},
-            {"Total Insights Analysis Completed", "0"},
-            {"Long Insight Count", "0"},
-            {"Short Insight Count", "0"},
-            {"Long/Short Ratio", "100%"},
-            {"Estimated Monthly Alpha Value", "$0"},
-            {"Total Accumulated Estimated Alpha Value", "$0"},
-            {"Mean Population Estimated Insight Value", "$0"},
-            {"Mean Population Direction", "0%"},
-            {"Mean Population Magnitude", "0%"},
-            {"Rolling Averaged Population Direction", "0%"},
-            {"Rolling Averaged Population Magnitude", "0%"},
+            {"Portfolio Turnover", "0%"},
             {"OrderListHash", "d41d8cd98f00b204e9800998ecf8427e"}
         };
     }

Algorithm.CSharp/AddRemoveOptionUniverseRegressionAlgorithm.cs

@@ -79,7 +79,7 @@ namespace QuantConnect.Algorithm.CSharp
                 // things like manually added, auto added, internal, and any other boolean state we need to track against a single security)
                 throw new Exception("The underlying equity data should NEVER be removed in this algorithm because it was manually added");
             }
-            if (_expectedSecurities.AreDifferent(Securities.Keys.ToHashSet()))
+            if (_expectedSecurities.AreDifferent(Securities.Total.Select(x => x.Symbol).ToHashSet()))
             {
                 var expected = string.Join(Environment.NewLine, _expectedSecurities.OrderBy(s => s.ToString()));
                 var actual = string.Join(Environment.NewLine, Securities.Keys.OrderBy(s => s.ToString()));
@@ -116,7 +116,7 @@ namespace QuantConnect.Algorithm.CSharp
                     }
                     // find first put above market price
                     return u.IncludeWeeklys()
-                        .Strikes(+1, +1)
+                        .Strikes(+1, +3)
                         .Expiration(TimeSpan.Zero, TimeSpan.FromDays(1))
                         .Contracts(c => c.Where(s => s.ID.OptionRight == OptionRight.Put));
                 });
@@ -141,16 +141,6 @@ namespace QuantConnect.Algorithm.CSharp
 
         public override void OnSecuritiesChanged(SecurityChanges changes)
         {
-            if (changes.AddedSecurities.Count > 1)
-            {
-                // added event fired for underlying since it was added to the option chain universe
-                if (changes.AddedSecurities.All(s => s.Symbol != Underlying))
-                {
-                    var securities = string.Join(Environment.NewLine, changes.AddedSecurities.Select(s => s.Symbol));
-                    throw new Exception($"This algorithm intends to add a single security at a time but added: {changes.AddedSecurities.Count}{Environment.NewLine}{securities}");
-                }
-            }
-
             if (changes.AddedSecurities.Any())
             {
                 foreach (var added in changes.AddedSecurities)
@@ -213,7 +203,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 200618;
+        public long DataPoints => 200807;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -233,6 +223,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Expectancy", "0"},
             {"Net Profit", "0%"},
             {"Sharpe Ratio", "0"},
+            {"Sortino Ratio", "0"},
             {"Probabilistic Sharpe Ratio", "0%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
@@ -245,28 +236,10 @@ namespace QuantConnect.Algorithm.CSharp
             {"Tracking Error", "0"},
             {"Treynor Ratio", "0"},
             {"Total Fees", "$6.00"},
-            {"Estimated Strategy Capacity", "$2000.00"},
+            {"Estimated Strategy Capacity", "$3000.00"},
             {"Lowest Capacity Asset", "GOOCV 305RBR0BSWIX2|GOOCV VP83T1ZUHROL"},
-            {"Fitness Score", "0"},
-            {"Kelly Criterion Estimate", "0"},
-            {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "0"},
-            {"Return Over Maximum Drawdown", "0"},
-            {"Portfolio Turnover", "0"},
-            {"Total Insights Generated", "0"},
-            {"Total Insights Closed", "0"},
-            {"Total Insights Analysis Completed", "0"},
-            {"Long Insight Count", "0"},
-            {"Short Insight Count", "0"},
-            {"Long/Short Ratio", "100%"},
-            {"Estimated Monthly Alpha Value", "$0"},
-            {"Total Accumulated Estimated Alpha Value", "$0"},
-            {"Mean Population Estimated Insight Value", "$0"},
-            {"Mean Population Direction", "0%"},
-            {"Mean Population Magnitude", "0%"},
-            {"Rolling Averaged Population Direction", "0%"},
-            {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "550a99c482106defd8ba15f48183768e"}
+            {"Portfolio Turnover", "1.49%"},
+            {"OrderListHash", "3adcc7ebf4153baabb073a8152e8cb2b"}
         };
     }
 }

Algorithm.CSharp/AddRemoveSecurityCacheRegressionAlgorithm.cs

@@ -102,41 +102,24 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "2.500%"},
             {"Expectancy", "-1"},
             {"Net Profit", "1.754%"},
-            {"Sharpe Ratio", "11.994"},
+            {"Sharpe Ratio", "11.954"},
+            {"Sortino Ratio", "29.606"},
             {"Probabilistic Sharpe Ratio", "74.160%"},
             {"Loss Rate", "100%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "0.618"},
+            {"Alpha", "0.616"},
             {"Beta", "0.81"},
             {"Annual Standard Deviation", "0.185"},
             {"Annual Variance", "0.034"},
             {"Information Ratio", "3.961"},
             {"Tracking Error", "0.061"},
-            {"Treynor Ratio", "2.746"},
+            {"Treynor Ratio", "2.737"},
             {"Total Fees", "$21.45"},
             {"Estimated Strategy Capacity", "$830000.00"},
             {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
-            {"Fitness Score", "0.204"},
-            {"Kelly Criterion Estimate", "0"},
-            {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "43.135"},
-            {"Return Over Maximum Drawdown", "261.238"},
-            {"Portfolio Turnover", "0.204"},
-            {"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", "6ee62edf1ac883882b0fcef8cb3e9bae"}
+            {"Portfolio Turnover", "20.49%"},
+            {"OrderListHash", "48d8e1195003665a2febf547c075d07f"}
         };
     }
 }

Algorithm.CSharp/AddRemoveSecurityRegressionAlgorithm.cs

@@ -128,41 +128,24 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "1.400%"},
             {"Expectancy", "0"},
             {"Net Profit", "1.776%"},
-            {"Sharpe Ratio", "13.013"},
+            {"Sharpe Ratio", "12.966"},
+            {"Sortino Ratio", "0"},
             {"Probabilistic Sharpe Ratio", "80.409%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "100%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "0.68"},
+            {"Alpha", "0.678"},
             {"Beta", "0.707"},
             {"Annual Standard Deviation", "0.16"},
             {"Annual Variance", "0.026"},
             {"Information Ratio", "1.378"},
             {"Tracking Error", "0.072"},
-            {"Treynor Ratio", "2.946"},
+            {"Treynor Ratio", "2.935"},
             {"Total Fees", "$28.30"},
             {"Estimated Strategy Capacity", "$4700000.00"},
             {"Lowest Capacity Asset", "AIG R735QTJ8XC9X"},
-            {"Fitness Score", "0.374"},
-            {"Kelly Criterion Estimate", "0"},
-            {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "372.086"},
-            {"Portfolio Turnover", "0.374"},
-            {"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", "ac3f4dfcdeb98b488b715412ad2d6c4f"}
+            {"Portfolio Turnover", "29.88%"},
+            {"OrderListHash", "b26f2f30082b754b065c41bb0ace44cc"}
         };
     }
 }

Algorithm.CSharp/AddRiskManagementAlgorithm.cs

@@ -81,41 +81,24 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "2.200%"},
             {"Expectancy", "0"},
             {"Net Profit", "1.775%"},
-            {"Sharpe Ratio", "9.373"},
+            {"Sharpe Ratio", "9.34"},
+            {"Sortino Ratio", "0"},
             {"Probabilistic Sharpe Ratio", "68.302%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "100%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "0.105"},
+            {"Alpha", "0.106"},
             {"Beta", "1.021"},
             {"Annual Standard Deviation", "0.227"},
             {"Annual Variance", "0.052"},
             {"Information Ratio", "25.083"},
             {"Tracking Error", "0.006"},
-            {"Treynor Ratio", "2.086"},
+            {"Treynor Ratio", "2.079"},
             {"Total Fees", "$10.33"},
             {"Estimated Strategy Capacity", "$38000000.00"},
             {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
-            {"Fitness Score", "0.747"},
-            {"Kelly Criterion Estimate", "38.796"},
-            {"Kelly Criterion Probability Value", "0.228"},
-            {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "107.013"},
-            {"Portfolio Turnover", "0.747"},
-            {"Total Insights Generated", "100"},
-            {"Total Insights Closed", "99"},
-            {"Total Insights Analysis Completed", "99"},
-            {"Long Insight Count", "100"},
-            {"Short Insight Count", "0"},
-            {"Long/Short Ratio", "100%"},
-            {"Estimated Monthly Alpha Value", "$135639.1761"},
-            {"Total Accumulated Estimated Alpha Value", "$21852.9784"},
-            {"Mean Population Estimated Insight Value", "$220.7372"},
-            {"Mean Population Direction", "53.5354%"},
-            {"Mean Population Magnitude", "53.5354%"},
-            {"Rolling Averaged Population Direction", "58.2788%"},
-            {"Rolling Averaged Population Magnitude", "58.2788%"},
-            {"OrderListHash", "af3a9c98c190d1b6b36fad184e796b0b"}
+            {"Portfolio Turnover", "59.74%"},
+            {"OrderListHash", "b5a7935f37d94eb20f6bcd88578dbaee"}
         };
     }
 }

Algorithm.CSharp/AddTwoAndRemoveOneOptionContractRegressionAlgorithm.cs

@@ -121,6 +121,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Expectancy", "0"},
             {"Net Profit", "0%"},
             {"Sharpe Ratio", "0"},
+            {"Sortino Ratio", "0"},
             {"Probabilistic Sharpe Ratio", "0%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
@@ -135,26 +136,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Fees", "$2.00"},
             {"Estimated Strategy Capacity", "$230000.00"},
             {"Lowest Capacity Asset", "AAPL VXBK4QQIRLZA|AAPL R735QTJ8XC9X"},
-            {"Fitness Score", "0"},
-            {"Kelly Criterion Estimate", "0"},
-            {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "0"},
-            {"Return Over Maximum Drawdown", "0"},
-            {"Portfolio Turnover", "0"},
-            {"Total Insights Generated", "0"},
-            {"Total Insights Closed", "0"},
-            {"Total Insights Analysis Completed", "0"},
-            {"Long Insight Count", "0"},
-            {"Short Insight Count", "0"},
-            {"Long/Short Ratio", "100%"},
-            {"Estimated Monthly Alpha Value", "$0"},
-            {"Total Accumulated Estimated Alpha Value", "$0"},
-            {"Mean Population Estimated Insight Value", "$0"},
-            {"Mean Population Direction", "0%"},
-            {"Mean Population Magnitude", "0%"},
-            {"Rolling Averaged Population Direction", "0%"},
-            {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "228194dcc6fd8689a67f383577ee2d85"}
+            {"Portfolio Turnover", "0.25%"},
+            {"OrderListHash", "afec48c499382b1d01af22daafe9f648"}
         };
     }
 }

Algorithm.CSharp/AddUniverseSelectionModelAlgorithm.cs

@@ -93,48 +93,31 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
-            {"Total Trades", "11"},
+            {"Total Trades", "10"},
             {"Average Win", "0%"},
             {"Average Loss", "-0.01%"},
-            {"Compounding Annual Return", "-14.217%"},
+            {"Compounding Annual Return", "-14.233%"},
             {"Drawdown", "3.300%"},
             {"Expectancy", "-1"},
             {"Net Profit", "-0.168%"},
-            {"Sharpe Ratio", "62.513"},
+            {"Sharpe Ratio", "62.464"},
+            {"Sortino Ratio", "0"},
             {"Probabilistic Sharpe Ratio", "0%"},
             {"Loss Rate", "100%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "1.118"},
+            {"Alpha", "1.117"},
             {"Beta", "1.19"},
             {"Annual Standard Deviation", "0.213"},
             {"Annual Variance", "0.046"},
-            {"Information Ratio", "70.862"},
+            {"Information Ratio", "70.778"},
             {"Tracking Error", "0.043"},
-            {"Treynor Ratio", "11.209"},
-            {"Total Fees", "$23.21"},
+            {"Treynor Ratio", "11.2"},
+            {"Total Fees", "$22.21"},
             {"Estimated Strategy Capacity", "$340000000.00"},
             {"Lowest Capacity Asset", "FB V6OIPNZEM8V9"},
-            {"Fitness Score", "0.147"},
-            {"Kelly Criterion Estimate", "0"},
-            {"Kelly Criterion Probability Value", "1"},
-            {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "-4.352"},
-            {"Portfolio Turnover", "0.269"},
-            {"Total Insights Generated", "15"},
-            {"Total Insights Closed", "12"},
-            {"Total Insights Analysis Completed", "12"},
-            {"Long Insight Count", "15"},
-            {"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", "a7a0983c8413ff241e7d223438f3d508"}
+            {"Portfolio Turnover", "26.92%"},
+            {"OrderListHash", "be09b39c5d01b0694f474ea7f7c5ae09"}
         };
     }
 }

Algorithm.CSharp/AddUniverseSelectionModelCoarseAlgorithm.cs

@@ -104,48 +104,31 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
-            {"Total Trades", "27"},
-            {"Average Win", "0.01%"},
+            {"Total Trades", "21"},
+            {"Average Win", "0.00%"},
             {"Average Loss", "-0.01%"},
-            {"Compounding Annual Return", "-75.320%"},
+            {"Compounding Annual Return", "-75.275%"},
             {"Drawdown", "5.800%"},
-            {"Expectancy", "-0.731"},
-            {"Net Profit", "-5.588%"},
-            {"Sharpe Ratio", "-3.252"},
-            {"Probabilistic Sharpe Ratio", "5.526%"},
-            {"Loss Rate", "86%"},
-            {"Win Rate", "14%"},
-            {"Profit-Loss Ratio", "0.89"},
-            {"Alpha", "-0.499"},
-            {"Beta", "1.483"},
+            {"Expectancy", "-0.609"},
+            {"Net Profit", "-5.581%"},
+            {"Sharpe Ratio", "-3.288"},
+            {"Sortino Ratio", "-3.828"},
+            {"Probabilistic Sharpe Ratio", "5.546%"},
+            {"Loss Rate", "73%"},
+            {"Win Rate", "27%"},
+            {"Profit-Loss Ratio", "0.43"},
+            {"Alpha", "-0.495"},
+            {"Beta", "1.484"},
             {"Annual Standard Deviation", "0.196"},
             {"Annual Variance", "0.039"},
-            {"Information Ratio", "-3.844"},
-            {"Tracking Error", "0.142"},
-            {"Treynor Ratio", "-0.43"},
-            {"Total Fees", "$37.25"},
-            {"Estimated Strategy Capacity", "$520000000.00"},
+            {"Information Ratio", "-3.843"},
+            {"Tracking Error", "0.141"},
+            {"Treynor Ratio", "-0.435"},
+            {"Total Fees", "$31.25"},
+            {"Estimated Strategy Capacity", "$550000000.00"},
             {"Lowest Capacity Asset", "AAPL R735QTJ8XC9X"},
-            {"Fitness Score", "0.004"},
-            {"Kelly Criterion Estimate", "0"},
-            {"Kelly Criterion Probability Value", "1"},
-            {"Sortino Ratio", "-4.469"},
-            {"Return Over Maximum Drawdown", "-13.057"},
-            {"Portfolio Turnover", "0.084"},
-            {"Total Insights Generated", "33"},
-            {"Total Insights Closed", "30"},
-            {"Total Insights Analysis Completed", "30"},
-            {"Long Insight Count", "33"},
-            {"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", "f837879b96f5e565b60fd040299d2123"}
+            {"Portfolio Turnover", "7.33%"},
+            {"OrderListHash", "b2ec2148ac94b67038a5bb4a2655f0a6"}
         };
     }
 }

Algorithm.CSharp/AdjustedVolumeRegressionAlgorithm.cs

@@ -176,6 +176,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Expectancy", "0"},
             {"Net Profit", "0%"},
             {"Sharpe Ratio", "0"},
+            {"Sortino Ratio", "0"},
             {"Probabilistic Sharpe Ratio", "0%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
@@ -190,26 +191,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Fees", "$21.60"},
             {"Estimated Strategy Capacity", "$42000000.00"},
             {"Lowest Capacity Asset", "AAPL R735QTJ8XC9X"},
-            {"Fitness Score", "0"},
-            {"Kelly Criterion Estimate", "0"},
-            {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "0"},
-            {"Return Over Maximum Drawdown", "0"},
-            {"Portfolio Turnover", "0"},
-            {"Total Insights Generated", "0"},
-            {"Total Insights Closed", "0"},
-            {"Total Insights Analysis Completed", "0"},
-            {"Long Insight Count", "0"},
-            {"Short Insight Count", "0"},
-            {"Long/Short Ratio", "100%"},
-            {"Estimated Monthly Alpha Value", "$0"},
-            {"Total Accumulated Estimated Alpha Value", "$0"},
-            {"Mean Population Estimated Insight Value", "$0"},
-            {"Mean Population Direction", "0%"},
-            {"Mean Population Magnitude", "0%"},
-            {"Rolling Averaged Population Direction", "0%"},
-            {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "18e41dded4f8cee548ee02b03ffb0814"}
+            {"Portfolio Turnover", "99.56%"},
+            {"OrderListHash", "92cacc8a537ff29960b6d092c3f92cf1"}
         };
     }
 }

Algorithm.CSharp/AlgorithmModeAndDeploymentTargetAlgorithm.cs

@@ -0,0 +1,112 @@
+/*
+ * 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.Interfaces;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Algorithm asserting the correct values for the deployment target and algorithm mode.
+    /// </summary>
+    public class AlgorithmModeAndDeploymentTargetAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        public override void Initialize()
+        {
+            SetStartDate(2013, 10, 07);
+            SetEndDate(2013, 10, 07);
+            SetCash(100000);
+
+            Debug($"Algorithm Mode: {AlgorithmMode}. Is Live Mode: {LiveMode}. Deployment Target: {DeploymentTarget}.");
+
+            if (AlgorithmMode != AlgorithmMode.Backtesting)
+            {
+                throw new Exception($"Algorithm mode is not backtesting. Actual: {AlgorithmMode}");
+            }
+
+            if (LiveMode)
+            {
+                throw new Exception("Algorithm should not be live");
+            }
+
+            if (DeploymentTarget != DeploymentTarget.LocalPlatform)
+            {
+                throw new Exception($"Algorithm deployment target is not local. Actual{DeploymentTarget}");
+            }
+
+            // For a live deployment these checks should pass:
+            //if (AlgorithmMode != AlgorithmMode.Live) throw new Exception("Algorithm mode is not live");
+            //if (!LiveMode) throw new Exception("Algorithm should be live");
+
+            // For a cloud deployment these checks should pass:
+            //if (DeploymentTarget != DeploymentTarget.CloudPlatform) throw new Exception("Algorithm deployment target is not cloud");
+
+            Quit();
+        }
+
+        /// <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>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 0;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public int AlgorithmHistoryDataPoints => 0;
+
+        /// <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"},
+            {"Sortino 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"},
+            {"Estimated Strategy Capacity", "$0"},
+            {"Lowest Capacity Asset", ""},
+            {"Portfolio Turnover", "0%"},
+            {"OrderListHash", "d41d8cd98f00b204e9800998ecf8427e"}
+        };
+    }
+}

Algorithm.CSharp/AllShortableSymbolsCoarseSelectionRegressionAlgorithm.cs

@@ -17,10 +17,12 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using QuantConnect.Brokerages;
+using QuantConnect.Securities;
 using QuantConnect.Data;
 using QuantConnect.Data.Shortable;
 using QuantConnect.Data.UniverseSelection;
 using QuantConnect.Interfaces;
+using System.IO;
 
 namespace QuantConnect.Algorithm.CSharp
 {
@@ -82,11 +84,15 @@ namespace QuantConnect.Algorithm.CSharp
             { _20140329, new Symbol[0] }
         };
 
+        private Security _security;
+
         public override void Initialize()
         {
             SetStartDate(2014, 3, 25);
             SetEndDate(2014, 3, 29);
             SetCash(10000000);
+            _security = AddEquity(_spy);
+            _security.SetShortableProvider(new RegressionTestShortableProvider());
 
             AddUniverse(CoarseSelection);
             UniverseSettings.Resolution = Resolution.Daily;
@@ -120,7 +126,7 @@ namespace QuantConnect.Algorithm.CSharp
 
         private IEnumerable<Symbol> CoarseSelection(IEnumerable<CoarseFundamental> coarse)
         {
-            var shortableSymbols = AllShortableSymbols();
+            var shortableSymbols = (_security.ShortableProvider as dynamic).AllShortableSymbols(Time);
             var selectedSymbols = coarse
                 .Select(x => x.Symbol)
                 .Where(s => shortableSymbols.ContainsKey(s) && shortableSymbols[s] >= 500)
@@ -165,15 +171,60 @@ namespace QuantConnect.Algorithm.CSharp
         {
             public AllShortableSymbolsRegressionAlgorithmBrokerageModel() : base()
             {
-                ShortableProvider = new RegressionTestShortableProvider();
+            }
+            public override IShortableProvider GetShortableProvider(Security security)
+            {
+                return new RegressionTestShortableProvider();
             }
         }
 
         private class RegressionTestShortableProvider : LocalDiskShortableProvider
         {
-            public RegressionTestShortableProvider() : base(SecurityType.Equity, "testbrokerage", Market.USA)
+            public RegressionTestShortableProvider() : base("testbrokerage")
             {
             }
+
+            /// <summary>
+            /// Gets a list of all shortable Symbols, including the quantity shortable as a Dictionary.
+            /// </summary>
+            /// <param name="localTime">The algorithm's local time</param>
+            /// <returns>Symbol/quantity shortable as a Dictionary. Returns null if no entry data exists for this date or brokerage</returns>
+            public Dictionary<Symbol, long> AllShortableSymbols(DateTime localTime)
+            {
+                var shortableDataDirectory = Path.Combine(Globals.DataFolder, SecurityType.Equity.SecurityTypeToLower(), Market.USA, "shortable", Brokerage);
+                var allSymbols = new Dictionary<Symbol, long>();
+
+                // Check backwards up to one week to see if we can source a previous file.
+                // If not, then we return a list of all Symbols with quantity set to zero.
+                var i = 0;
+                while (i <= 7)
+                {
+                    var shortableListFile = Path.Combine(shortableDataDirectory, "dates", $"{localTime.AddDays(-i):yyyyMMdd}.csv");
+
+                    foreach (var line in DataProvider.ReadLines(shortableListFile))
+                    {
+                        var csv = line.Split(',');
+                        var ticker = csv[0];
+
+                        var symbol = new Symbol(
+                                SecurityIdentifier.GenerateEquity(ticker, QuantConnect.Market.USA,
+                                    mappingResolveDate: localTime), ticker);
+                        var quantity = Parse.Long(csv[1]);
+
+                        allSymbols[symbol] = quantity;
+                    }
+
+                    if (allSymbols.Count > 0)
+                    {
+                        return allSymbols;
+                    }
+
+                    i++;
+                }
+
+                // Return our empty dictionary if we did not find a file to extract
+                return allSymbols;
+            }
         }
 
         /// <summary>
@@ -189,7 +240,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 35410;
+        public long DataPoints => 37754;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -208,41 +259,24 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "0%"},
             {"Expectancy", "0"},
             {"Net Profit", "0.192%"},
-            {"Sharpe Ratio", "231.673"},
+            {"Sharpe Ratio", "221.176"},
+            {"Sortino Ratio", "0"},
             {"Probabilistic Sharpe Ratio", "0%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "0.163"},
+            {"Alpha", "0.156"},
             {"Beta", "-0.007"},
             {"Annual Standard Deviation", "0.001"},
             {"Annual Variance", "0"},
             {"Information Ratio", "4.804"},
             {"Tracking Error", "0.098"},
-            {"Treynor Ratio", "-22.526"},
+            {"Treynor Ratio", "-21.505"},
             {"Total Fees", "$307.50"},
             {"Estimated Strategy Capacity", "$2600000.00"},
             {"Lowest Capacity Asset", "GOOCV VP83T1ZUHROL"},
-            {"Fitness Score", "0.106"},
-            {"Kelly Criterion Estimate", "0"},
-            {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "79228162514264337593543950335"},
-            {"Portfolio Turnover", "0.106"},
-            {"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", "0069f402ffcd2d91b9018b81badfab81"}
+            {"Portfolio Turnover", "10.61%"},
+            {"OrderListHash", "9c129e856afe96579b52cbfe95237100"}
         };
     }
 }

Algorithm.CSharp/AlphaStreamsBasicTemplateAlgorithm.cs

@@ -1,127 +0,0 @@
-/*
- * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
- * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
-*/
-
-using QuantConnect.Orders;
-using QuantConnect.Interfaces;
-using QuantConnect.Securities;
-using System.Collections.Generic;
-using QuantConnect.Data.Custom.AlphaStreams;
-using QuantConnect.Algorithm.Framework.Alphas;
-using QuantConnect.Algorithm.Framework.Execution;
-using QuantConnect.Algorithm.Framework.Portfolio;
-
-namespace QuantConnect.Algorithm.CSharp
-{
-    /// <summary>
-    /// Example algorithm consuming an alpha streams portfolio state and trading based on it
-    /// </summary>
-    public class AlphaStreamsBasicTemplateAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
-    {
-        /// <summary>
-        /// Initialise the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must initialized.
-        /// </summary>
-        public override void Initialize()
-        {
-            SetStartDate(2018, 04, 04);
-            SetEndDate(2018, 04, 06);
-
-            SetAlpha(new AlphaStreamAlphaModule());
-            SetExecution(new ImmediateExecutionModel());
-            Settings.MinimumOrderMarginPortfolioPercentage = 0.01m;
-            SetPortfolioConstruction(new EqualWeightingAlphaStreamsPortfolioConstructionModel());
-            SetSecurityInitializer(new BrokerageModelSecurityInitializer(BrokerageModel,
-                new FuncSecuritySeeder(GetLastKnownPrices)));
-
-            foreach (var alphaId in new [] { "623b06b231eb1cc1aa3643a46", "9fc8ef73792331b11dbd5429a" })
-            {
-                AddData<AlphaStreamsPortfolioState>(alphaId);
-            }
-        }
-
-        public override void OnOrderEvent(OrderEvent orderEvent)
-        {
-            Log($"OnOrderEvent: {orderEvent}");
-        }
-
-        /// <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>
-        /// Data Points count of all timeslices of algorithm
-        /// </summary>
-        public virtual long DataPoints => 890;
-
-        /// <summary>
-        /// Data Points count of the algorithm history
-        /// </summary>
-        public virtual int AlgorithmHistoryDataPoints => 12;
-
-        /// <summary>
-        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
-        /// </summary>
-        public virtual Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
-        {
-            {"Total Trades", "2"},
-            {"Average Win", "0%"},
-            {"Average Loss", "-0.12%"},
-            {"Compounding Annual Return", "-14.722%"},
-            {"Drawdown", "0.200%"},
-            {"Expectancy", "-1"},
-            {"Net Profit", "-0.116%"},
-            {"Sharpe Ratio", "0"},
-            {"Probabilistic Sharpe Ratio", "0%"},
-            {"Loss Rate", "100%"},
-            {"Win Rate", "0%"},
-            {"Profit-Loss Ratio", "0"},
-            {"Alpha", "0"},
-            {"Beta", "0"},
-            {"Annual Standard Deviation", "0"},
-            {"Annual Variance", "0"},
-            {"Information Ratio", "2.474"},
-            {"Tracking Error", "0.339"},
-            {"Treynor Ratio", "0"},
-            {"Total Fees", "$0.00"},
-            {"Estimated Strategy Capacity", "$83000.00"},
-            {"Lowest Capacity Asset", "BTCUSD XJ"},
-            {"Fitness Score", "0.017"},
-            {"Kelly Criterion Estimate", "0"},
-            {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "-138.588"},
-            {"Portfolio Turnover", "0.034"},
-            {"Total Insights Generated", "0"},
-            {"Total Insights Closed", "0"},
-            {"Total Insights Analysis Completed", "0"},
-            {"Long Insight Count", "0"},
-            {"Short Insight Count", "0"},
-            {"Long/Short Ratio", "100%"},
-            {"Estimated Monthly Alpha Value", "$0"},
-            {"Total Accumulated Estimated Alpha Value", "$0"},
-            {"Mean Population Estimated Insight Value", "$0"},
-            {"Mean Population Direction", "0%"},
-            {"Mean Population Magnitude", "0%"},
-            {"Rolling Averaged Population Direction", "0%"},
-            {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "2b94bc50a74caebe06c075cdab1bc6da"}
-        };
-    }
-}

Algorithm.CSharp/AlphaStreamsDifferentAccountCurrencyBasicTemplateAlgorithm.cs

@@ -1,103 +0,0 @@
-/*
- * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
- * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
-*/
-
-using System.Collections.Generic;
-
-namespace QuantConnect.Algorithm.CSharp
-{
-    /// <summary>
-    /// Example algorithm with existing holdings consuming an alpha streams portfolio state and trading based on it
-    /// </summary>
-    public class AlphaStreamsDifferentAccountCurrencyBasicTemplateAlgorithm : AlphaStreamsWithHoldingsBasicTemplateAlgorithm
-    {
-        /// <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()
-        {
-            SetAccountCurrency("EUR");
-            base.Initialize();
-        }
-
-        /// <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>
-        /// Data Points count of all timeslices of algorithm
-        /// </summary>
-        public override long DataPoints => 6214;
-
-        /// <summary>
-        /// Data Points count of the algorithm history
-        /// </summary>
-        public override int AlgorithmHistoryDataPoints => 61;
-
-        /// <summary>
-        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
-        /// </summary>
-        public override Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
-        {
-            {"Total Trades", "2"},
-            {"Average Win", "0.01%"},
-            {"Average Loss", "0.00%"},
-            {"Compounding Annual Return", "-78.502%"},
-            {"Drawdown", "3.100%"},
-            {"Expectancy", "7.797"},
-            {"Net Profit", "-1.134%"},
-            {"Sharpe Ratio", "-2.456"},
-            {"Probabilistic Sharpe Ratio", "0%"},
-            {"Loss Rate", "50%"},
-            {"Win Rate", "50%"},
-            {"Profit-Loss Ratio", "16.59"},
-            {"Alpha", "0.006"},
-            {"Beta", "1.011"},
-            {"Annual Standard Deviation", "0.343"},
-            {"Annual Variance", "0.117"},
-            {"Information Ratio", "-0.859"},
-            {"Tracking Error", "0.004"},
-            {"Treynor Ratio", "-0.832"},
-            {"Total Fees", "€2.89"},
-            {"Estimated Strategy Capacity", "€8900000000.00"},
-            {"Lowest Capacity Asset", "AAPL R735QTJ8XC9X"},
-            {"Fitness Score", "0.506"},
-            {"Kelly Criterion Estimate", "0"},
-            {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "79228162514264337593543950335"},
-            {"Portfolio Turnover", "0.506"},
-            {"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", "a9dd0a0ab6070455479d1b9caaa4e69c"}
-        };
-    }
-}

Algorithm.CSharp/AlphaStreamsUniverseSelectionTemplateAlgorithm.cs

@@ -1,140 +0,0 @@
-/*
- * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
- * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
-*/
-
-using System;
-using QuantConnect.Interfaces;
-using System.Collections.Generic;
-using QuantConnect.Data.UniverseSelection;
-using QuantConnect.Data.Custom.AlphaStreams;
-using QuantConnect.Algorithm.Framework.Alphas;
-using QuantConnect.Algorithm.Framework.Execution;
-using QuantConnect.Algorithm.Framework.Portfolio;
-using QuantConnect.Algorithm.Framework.Selection;
-
-namespace QuantConnect.Algorithm.CSharp
-{
-    /// <summary>
-    /// Example algorithm consuming an alpha streams portfolio state and trading based on it
-    /// </summary>
-    public class AlphaStreamsUniverseSelectionTemplateAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
-    {
-        /// <summary>
-        /// Initialise the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must initialized.
-        /// </summary>
-        public override void Initialize()
-        {
-            SetStartDate(2018, 04, 04);
-            SetEndDate(2018, 04, 06);
-
-            SetAlpha(new AlphaStreamAlphaModule());
-            SetExecution(new ImmediateExecutionModel());
-            Settings.MinimumOrderMarginPortfolioPercentage = 0.01m;
-            SetPortfolioConstruction(new EqualWeightingAlphaStreamsPortfolioConstructionModel());
-
-            SetUniverseSelection(new ScheduledUniverseSelectionModel(
-                DateRules.EveryDay(),
-                TimeRules.Midnight,
-                SelectAlphas,
-                new UniverseSettings(UniverseSettings)
-                {
-                    SubscriptionDataTypes = new List<Tuple<Type, TickType>>
-                        {new(typeof(AlphaStreamsPortfolioState), TickType.Trade)},
-                    FillForward = false,
-                }
-            ));
-        }
-
-        private IEnumerable<Symbol> SelectAlphas(DateTime dateTime)
-        {
-            Log($"SelectAlphas() {Time}");
-            foreach (var alphaId in new[] {"623b06b231eb1cc1aa3643a46", "9fc8ef73792331b11dbd5429a"})
-            {
-                var alphaSymbol = new Symbol(SecurityIdentifier.GenerateBase(typeof(AlphaStreamsPortfolioState), alphaId, Market.USA),
-                        alphaId);
-
-                yield return alphaSymbol;
-            }
-        }
-
-        /// <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>
-        /// Data Points count of all timeslices of algorithm
-        /// </summary>
-        public long DataPoints => 893;
-
-        /// <summary>
-        /// Data Points count of the algorithm history
-        /// </summary>
-        public int AlgorithmHistoryDataPoints => 2;
-
-        /// <summary>
-        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
-        /// </summary>
-        public virtual Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
-        {
-            {"Total Trades", "2"},
-            {"Average Win", "0%"},
-            {"Average Loss", "-0.12%"},
-            {"Compounding Annual Return", "-13.200%"},
-            {"Drawdown", "0.200%"},
-            {"Expectancy", "-1"},
-            {"Net Profit", "-0.116%"},
-            {"Sharpe Ratio", "0"},
-            {"Probabilistic Sharpe Ratio", "0%"},
-            {"Loss Rate", "100%"},
-            {"Win Rate", "0%"},
-            {"Profit-Loss Ratio", "0"},
-            {"Alpha", "0"},
-            {"Beta", "0"},
-            {"Annual Standard Deviation", "0"},
-            {"Annual Variance", "0"},
-            {"Information Ratio", "2.474"},
-            {"Tracking Error", "0.339"},
-            {"Treynor Ratio", "0"},
-            {"Total Fees", "$0.00"},
-            {"Estimated Strategy Capacity", "$83000.00"},
-            {"Lowest Capacity Asset", "BTCUSD XJ"},
-            {"Fitness Score", "0.011"},
-            {"Kelly Criterion Estimate", "0"},
-            {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "-113.513"},
-            {"Portfolio Turnover", "0.023"},
-            {"Total Insights Generated", "0"},
-            {"Total Insights Closed", "0"},
-            {"Total Insights Analysis Completed", "0"},
-            {"Long Insight Count", "0"},
-            {"Short Insight Count", "0"},
-            {"Long/Short Ratio", "100%"},
-            {"Estimated Monthly Alpha Value", "$0"},
-            {"Total Accumulated Estimated Alpha Value", "$0"},
-            {"Mean Population Estimated Insight Value", "$0"},
-            {"Mean Population Direction", "0%"},
-            {"Mean Population Magnitude", "0%"},
-            {"Rolling Averaged Population Direction", "0%"},
-            {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "2b94bc50a74caebe06c075cdab1bc6da"}
-        };
-    }
-}

Algorithm.CSharp/AlphaStreamsWithHoldingsBasicTemplateAlgorithm.cs

@@ -1,154 +0,0 @@
-/*
- * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
- * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
-*/
-
-using System;
-using QuantConnect.Orders;
-using System.Collections.Generic;
-using QuantConnect.Data.Custom.AlphaStreams;
-using QuantConnect.Algorithm.Framework.Execution;
-using QuantConnect.Algorithm.Framework.Portfolio;
-
-namespace QuantConnect.Algorithm.CSharp
-{
-    /// <summary>
-    /// Example algorithm with existing holdings consuming an alpha streams portfolio state and trading based on it
-    /// </summary>
-    public class AlphaStreamsWithHoldingsBasicTemplateAlgorithm : AlphaStreamsBasicTemplateAlgorithm
-    {
-        private decimal _expectedSpyQuantity;
-        /// <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(2018, 04, 04);
-            SetEndDate(2018, 04, 06);
-            SetCash(100000);
-
-            SetExecution(new ImmediateExecutionModel());
-            UniverseSettings.Resolution = Resolution.Hour;
-            Settings.MinimumOrderMarginPortfolioPercentage = 0.001m;
-            SetPortfolioConstruction(new EqualWeightingAlphaStreamsPortfolioConstructionModel());
-
-            // AAPL should be liquidated since it's not hold by the alpha
-            // This is handled by the PCM
-            var aapl = AddEquity("AAPL", Resolution.Hour);
-            aapl.Holdings.SetHoldings(40, 10);
-
-            // SPY will be bought following the alpha streams portfolio
-            // This is handled by the PCM + Execution Model
-            var spy = AddEquity("SPY", Resolution.Hour);
-            spy.Holdings.SetHoldings(246, -10);
-
-            AddData<AlphaStreamsPortfolioState>("94d820a93fff127fa46c15231d");
-        }
-
-        public override void OnOrderEvent(OrderEvent orderEvent)
-        {
-            if (_expectedSpyQuantity == 0 && orderEvent.Symbol == "SPY" && orderEvent.Status == OrderStatus.Filled)
-            {
-                var security = Securities["SPY"];
-                var priceInAccountCurrency = Portfolio.CashBook.ConvertToAccountCurrency(security.AskPrice, security.QuoteCurrency.Symbol);
-                _expectedSpyQuantity = (Portfolio.TotalPortfolioValue - Settings.FreePortfolioValue) / priceInAccountCurrency;
-                _expectedSpyQuantity = _expectedSpyQuantity.DiscretelyRoundBy(1, MidpointRounding.ToZero);
-            }
-
-            base.OnOrderEvent(orderEvent);
-        }
-
-        public override void OnEndOfAlgorithm()
-        {
-            if (Securities["AAPL"].HoldStock)
-            {
-                throw new Exception("We should no longer hold AAPL since the alpha does not");
-            }
-
-            // we allow some padding for small price differences
-            if (Math.Abs(Securities["SPY"].Holdings.Quantity - _expectedSpyQuantity) > _expectedSpyQuantity * 0.03m)
-            {
-                throw new Exception($"Unexpected SPY holdings. Expected {_expectedSpyQuantity} was {Securities["SPY"].Holdings.Quantity}");
-            }
-        }
-
-        /// <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>
-        /// Data Points count of all timeslices of algorithm
-        /// </summary>
-        public override long DataPoints => 2313;
-
-        /// <summary>
-        /// Data Points count of the algorithm history
-        /// </summary>
-        public override int AlgorithmHistoryDataPoints => 1;
-
-        /// <summary>
-        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
-        /// </summary>
-        public override Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
-        {
-            {"Total Trades", "2"},
-            {"Average Win", "0.01%"},
-            {"Average Loss", "0.00%"},
-            {"Compounding Annual Return", "-87.617%"},
-            {"Drawdown", "3.100%"},
-            {"Expectancy", "8.518"},
-            {"Net Profit", "-1.515%"},
-            {"Sharpe Ratio", "-2.45"},
-            {"Probabilistic Sharpe Ratio", "0%"},
-            {"Loss Rate", "50%"},
-            {"Win Rate", "50%"},
-            {"Profit-Loss Ratio", "18.04"},
-            {"Alpha", "0.008"},
-            {"Beta", "1.015"},
-            {"Annual Standard Deviation", "0.344"},
-            {"Annual Variance", "0.118"},
-            {"Information Ratio", "-0.856"},
-            {"Tracking Error", "0.005"},
-            {"Treynor Ratio", "-0.83"},
-            {"Total Fees", "$3.09"},
-            {"Estimated Strategy Capacity", "$8900000000.00"},
-            {"Lowest Capacity Asset", "AAPL R735QTJ8XC9X"},
-            {"Fitness Score", "0.511"},
-            {"Kelly Criterion Estimate", "0"},
-            {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "6113.173"},
-            {"Portfolio Turnover", "0.511"},
-            {"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", "788eb2c74715a78476ba0db3b2654eb6"}
-        };
-    }
-}

Algorithm.CSharp/Alphas/GreenblattMagicFormulaAlpha.cs

@@ -195,11 +195,11 @@ namespace QuantConnect.Algorithm.CSharp.Alphas
             private const int _numberOfSymbolsFine = 20;
             private const int _numberOfSymbolsInPortfolio = 10;
             private int _lastMonth = -1;
-            private Dictionary<Symbol, decimal> _dollarVolumeBySymbol;
+            private Dictionary<Symbol, double> _dollarVolumeBySymbol;
 
             public GreenBlattMagicFormulaUniverseSelectionModel() : base(true)
             {
-                _dollarVolumeBySymbol = new Dictionary<Symbol, decimal>();
+                _dollarVolumeBySymbol = new ();
             }
 
             /// <summary>
@@ -245,7 +245,7 @@ namespace QuantConnect.Algorithm.CSharp.Alphas
                     where x.CompanyReference.CountryId == "USA"
                     where x.CompanyReference.PrimaryExchangeID == "NYS" || x.CompanyReference.PrimaryExchangeID == "NAS"
                     where (algorithm.Time - x.SecurityReference.IPODate).TotalDays > 180
-                    where x.EarningReports.BasicAverageShares.ThreeMonths * x.EarningReports.BasicEPS.TwelveMonths * x.ValuationRatios.PERatio > 5e8m
+                    where x.EarningReports.BasicAverageShares.ThreeMonths * x.EarningReports.BasicEPS.TwelveMonths * x.ValuationRatios.PERatio > 5e8
                     select x;
 
                 double count = filteredFine.Count();
@@ -287,4 +287,4 @@ namespace QuantConnect.Algorithm.CSharp.Alphas
             }
         }
     }
-}
+}

Algorithm.CSharp/AsynchronousUniverseRegressionAlgorithm.cs

@@ -1,4 +1,4 @@
-/*
+/*
  * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
  * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
  *
@@ -13,19 +13,21 @@
  * limitations under the License.
 */
 
-namespace QuantConnect.Algorithm.Framework.Alphas.Analysis
+namespace QuantConnect.Algorithm.CSharp
 {
     /// <summary>
-    /// Retrieves the registered scoring function for the specified insight/score type
+    /// Example algorithm using the asynchronous universe selection functionality
     /// </summary>
-    public interface IInsightScoreFunctionProvider
+    public class AsynchronousUniverseRegressionAlgorithm : FundamentalRegressionAlgorithm
     {
         /// <summary>
-        /// Gets the insight scoring function for the specified insight type and score type
+        /// Initialise the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must initialized.
         /// </summary>
-        /// <param name="insightType">The insight's type</param>
-        /// <param name="scoreType">The scoring type</param>
-        /// <returns>A function to be used to compute insight scores</returns>
-        IInsightScoreFunction GetScoreFunction(InsightType insightType, InsightScoreType scoreType);
+        public override void Initialize()
+        {
+            base.Initialize();
+
+            UniverseSettings.Asynchronous = true;
+        }
     }
-}
+}

Algorithm.CSharp/AutoRegressiveIntegratedMovingAverageRegressionAlgorithm.cs

@@ -95,41 +95,24 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "0.100%"},
             {"Expectancy", "3.321"},
             {"Net Profit", "0.089%"},
-            {"Sharpe Ratio", "0.798"},
+            {"Sharpe Ratio", "-8.214"},
+            {"Sortino Ratio", "-9.025"},
             {"Probabilistic Sharpe Ratio", "40.893%"},
             {"Loss Rate", "24%"},
             {"Win Rate", "76%"},
             {"Profit-Loss Ratio", "4.67"},
-            {"Alpha", "-0.001"},
+            {"Alpha", "-0.008"},
             {"Beta", "0.008"},
             {"Annual Standard Deviation", "0.001"},
             {"Annual Variance", "0"},
             {"Information Ratio", "-1.961"},
             {"Tracking Error", "0.092"},
-            {"Treynor Ratio", "0.08"},
+            {"Treynor Ratio", "-0.826"},
             {"Total Fees", "$52.00"},
             {"Estimated Strategy Capacity", "$32000000000.00"},
             {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
-            {"Fitness Score", "0"},
-            {"Kelly Criterion Estimate", "0"},
-            {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "1.266"},
-            {"Return Over Maximum Drawdown", "1.622"},
-            {"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", "cf43585a8d1781f04b53a4f1ee3380cb"}
+            {"Portfolio Turnover", "0.02%"},
+            {"OrderListHash", "e6711c76cb05bbb575ca067664348d88"}
         };
     }
 }

Algorithm.CSharp/AutomaticIndicatorWarmupDataTypeRegressionAlgorithm.cs

@@ -165,41 +165,24 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "15.900%"},
             {"Expectancy", "0"},
             {"Net Profit", "6.828%"},
-            {"Sharpe Ratio", "203744786353.302"},
+            {"Sharpe Ratio", "203744786353.299"},
+            {"Sortino Ratio", "0"},
             {"Probabilistic Sharpe Ratio", "0%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "456382350698.561"},
+            {"Alpha", "456382350698.622"},
             {"Beta", "9.229"},
             {"Annual Standard Deviation", "2.24"},
             {"Annual Variance", "5.017"},
             {"Information Ratio", "228504036840.953"},
             {"Tracking Error", "1.997"},
-            {"Treynor Ratio", "49450701625.718"},
+            {"Treynor Ratio", "49450701625.717"},
             {"Total Fees", "$23.65"},
             {"Estimated Strategy Capacity", "$200000000.00"},
             {"Lowest Capacity Asset", "ES VMKLFZIH2MTD"},
-            {"Fitness Score", "0.518"},
-            {"Kelly Criterion Estimate", "0"},
-            {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "-7.708"},
-            {"Portfolio Turnover", "5.277"},
-            {"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", "dd38e7b94027d20942a5aa9ac31a9a7f"}
+            {"Portfolio Turnover", "351.80%"},
+            {"OrderListHash", "23cf084b30ec3d70b1b9f54c9b3b975f"}
         };
     }
 }

Algorithm.CSharp/AutomaticIndicatorWarmupRegressionAlgorithm.cs

@@ -127,7 +127,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "2.200%"},
             {"Expectancy", "0"},
             {"Net Profit", "1.692%"},
-            {"Sharpe Ratio", "8.888"},
+            {"Sharpe Ratio", "8.854"},
+            {"Sortino Ratio", "0"},
             {"Probabilistic Sharpe Ratio", "67.609%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
@@ -138,30 +139,12 @@ namespace QuantConnect.Algorithm.CSharp
             {"Annual Variance", "0.049"},
             {"Information Ratio", "-14.565"},
             {"Tracking Error", "0.001"},
-            {"Treynor Ratio", "1.978"},
+            {"Treynor Ratio", "1.97"},
             {"Total Fees", "$3.44"},
             {"Estimated Strategy Capacity", "$56000000.00"},
             {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
-            {"Fitness Score", "0.248"},
-            {"Kelly Criterion Estimate", "0"},
-            {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "93.728"},
-            {"Portfolio Turnover", "0.248"},
-            {"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", "9e4bfd2eb0b81ee5bc1b197a87ccedbe"}
+            {"Portfolio Turnover", "19.93%"},
+            {"OrderListHash", "0c0f9328786b0c9e8f88d271673d16c3"}
         };
     }
 }

Algorithm.CSharp/BacktestingBrokerageRegressionAlgorithm.cs

@@ -296,7 +296,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 1748811;
+        public long DataPoints => 1267414;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -315,41 +315,24 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "0.400%"},
             {"Expectancy", "-1"},
             {"Net Profit", "-0.329%"},
-            {"Sharpe Ratio", "-7.887"},
+            {"Sharpe Ratio", "-14.095"},
+            {"Sortino Ratio", "0"},
             {"Probabilistic Sharpe Ratio", "1.216%"},
             {"Loss Rate", "100%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "-0.001"},
+            {"Alpha", "-0.01"},
             {"Beta", "0.097"},
             {"Annual Standard Deviation", "0.002"},
             {"Annual Variance", "0"},
             {"Information Ratio", "7.39"},
             {"Tracking Error", "0.015"},
-            {"Treynor Ratio", "-0.131"},
+            {"Treynor Ratio", "-0.234"},
             {"Total Fees", "$2.00"},
             {"Estimated Strategy Capacity", "$0"},
             {"Lowest Capacity Asset", "GOOCV VP83T1ZUHROL"},
-            {"Fitness Score", "0.212"},
-            {"Kelly Criterion Estimate", "0"},
-            {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "-73.334"},
-            {"Portfolio Turnover", "0.425"},
-            {"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", "f67306bc706a2cf66288f1cadf6148ed"}
+            {"Portfolio Turnover", "17.02%"},
+            {"OrderListHash", "a172538bd18fa82b11adaeac4f504b2e"}
         };
     }
 }

Algorithm.CSharp/BaseFrameworkRegressionAlgorithm.cs

@@ -0,0 +1,95 @@
+/*
+ * 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.Algorithm.Framework.Alphas;
+using QuantConnect.Algorithm.Framework.Execution;
+using QuantConnect.Algorithm.Framework.Portfolio;
+using QuantConnect.Algorithm.Framework.Risk;
+using QuantConnect.Algorithm.Framework.Selection;
+using QuantConnect.Interfaces;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Abstract regression framework algorithm for multiple framework regression tests
+    /// </summary>
+    public abstract class BaseFrameworkRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        public override void Initialize()
+        {
+            SetStartDate(2014, 6, 1);
+            SetEndDate(2014, 6, 30);
+
+            UniverseSettings.Resolution = Resolution.Hour;
+            UniverseSettings.DataNormalizationMode = DataNormalizationMode.Raw;
+
+            var symbols = new[] { "AAPL", "AIG", "BAC", "SPY" }
+                .Select(ticker => QuantConnect.Symbol.Create(ticker, SecurityType.Equity, Market.USA))
+                .ToList();
+
+            // Manually add AAPL and AIG when the algorithm starts
+            SetUniverseSelection(new ManualUniverseSelectionModel(symbols.Take(2)));
+
+            // At midnight, add all securities every day except on the last data
+            // With this procedure, the Alpha Model will experience multiple universe changes
+            AddUniverseSelection(new ScheduledUniverseSelectionModel(
+                DateRules.EveryDay(), TimeRules.Midnight,
+                dt => dt < EndDate.AddDays(-1) ? symbols : Enumerable.Empty<Symbol>()));
+
+            SetAlpha(new ConstantAlphaModel(InsightType.Price, InsightDirection.Up, TimeSpan.FromDays(31), 0.025, null));
+            SetPortfolioConstruction(new EqualWeightingPortfolioConstructionModel());
+            SetExecution(new ImmediateExecutionModel());
+            SetRiskManagement(new NullRiskManagementModel());
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            // The base implementation checks for active insights
+            var insightsCount = Insights.GetInsights(insight => insight.IsActive(UtcTime)).Count;
+            if (insightsCount != 0)
+            {
+                throw new Exception($"The number of active insights should be 0. Actual: {insightsCount}");
+            }
+        }
+
+        /// <summary>
+        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
+        /// </summary>
+        public bool CanRunLocally { get; } = true;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public virtual Language[] Languages { get; } = { Language.CSharp, Language.Python };
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public virtual long DataPoints => 765;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public virtual int AlgorithmHistoryDataPoints => 0;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public abstract Dictionary<string, string> ExpectedStatistics { get; }
+    }
+}

Algorithm.CSharp/BasicSetAccountCurrencyAlgorithm.cs

@@ -35,11 +35,15 @@ namespace QuantConnect.Algorithm.CSharp
             SetStartDate(2018, 04, 04);  //Set Start Date
             SetEndDate(2018, 04, 04);    //Set End Date
             SetBrokerageModel(BrokerageName.GDAX, AccountType.Cash);
+            SetAccountCurrency();
+            _btcEur = AddCrypto("BTCEUR").Symbol;
+        }
+
+        public virtual void SetAccountCurrency()
+        {
             //Before setting any cash or adding a Security call SetAccountCurrency
             SetAccountCurrency("EUR");
             SetCash(100000);             //Set Strategy Cash
-
-            _btcEur = AddCrypto("BTCEUR").Symbol;
         }
 
         /// <summary>
@@ -68,7 +72,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 4324;
+        public long DataPoints => 4319;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -88,6 +92,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Expectancy", "0"},
             {"Net Profit", "0%"},
             {"Sharpe Ratio", "0"},
+            {"Sortino Ratio", "0"},
             {"Probabilistic Sharpe Ratio", "0%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
@@ -101,27 +106,9 @@ namespace QuantConnect.Algorithm.CSharp
             {"Treynor Ratio", "0"},
             {"Total Fees", "€298.35"},
             {"Estimated Strategy Capacity", "€85000.00"},
-            {"Lowest Capacity Asset", "BTCEUR XJ"},
-            {"Fitness Score", "0.506"},
-            {"Kelly Criterion Estimate", "0"},
-            {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "-13.614"},
-            {"Portfolio Turnover", "1.073"},
-            {"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", "2ba443899dcccc79dc0f04441f797bf9"}
+            {"Lowest Capacity Asset", "BTCEUR 2XR"},
+            {"Portfolio Turnover", "107.64%"},
+            {"OrderListHash", "b0544d71cee600ef1f09c6000d6a3229"}
         };
     }
 }

Algorithm.CSharp/BasicSetAccountCurrencyWithAmountAlgorithm.cs

@@ -0,0 +1,84 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
+using System.Collections.Generic;
+using QuantConnect.Interfaces;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Basic algorithm using SetAccountCurrency with an amount
+    /// </summary>
+    public class BasicSetAccountCurrencyWithAmountAlgorithm : BasicSetAccountCurrencyAlgorithm, IRegressionAlgorithmDefinition
+    {
+        public override void SetAccountCurrency()
+        {
+            //Before setting any cash or adding a Security call SetAccountCurrency
+            SetAccountCurrency("EUR", 200000);
+        }
+
+        /// <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>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 4319;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public int AlgorithmHistoryDataPoints => 120;
+
+        /// <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"},
+            {"Sortino 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", "€596.71"},
+            {"Estimated Strategy Capacity", "€85000.00"},
+            {"Lowest Capacity Asset", "BTCEUR 2XR"},
+            {"Portfolio Turnover", "107.64%"},
+            {"OrderListHash", "64c44a56824e67b86213539212d08e25"}
+        };
+    }
+}

Algorithm.CSharp/BasicTemplateAlgorithm.cs

@@ -94,7 +94,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "2.200%"},
             {"Expectancy", "0"},
             {"Net Profit", "1.692%"},
-            {"Sharpe Ratio", "8.888"},
+            {"Sharpe Ratio", "8.854"},
+            {"Sortino Ratio", "0"},
             {"Probabilistic Sharpe Ratio", "67.609%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
@@ -105,30 +106,12 @@ namespace QuantConnect.Algorithm.CSharp
             {"Annual Variance", "0.049"},
             {"Information Ratio", "-14.565"},
             {"Tracking Error", "0.001"},
-            {"Treynor Ratio", "1.978"},
+            {"Treynor Ratio", "1.97"},
             {"Total Fees", "$3.44"},
             {"Estimated Strategy Capacity", "$56000000.00"},
             {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
-            {"Fitness Score", "0.248"},
-            {"Kelly Criterion Estimate", "0"},
-            {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "93.728"},
-            {"Portfolio Turnover", "0.248"},
-            {"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", "9e4bfd2eb0b81ee5bc1b197a87ccedbe"}
+            {"Portfolio Turnover", "19.93%"},
+            {"OrderListHash", "0c0f9328786b0c9e8f88d271673d16c3"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateAxosAlgorithm.cs

@@ -14,7 +14,6 @@
 */
 
 using QuantConnect.Data;
-using QuantConnect.Orders;
 using QuantConnect.Interfaces;
 using QuantConnect.Brokerages;
 using System.Collections.Generic;
@@ -22,12 +21,12 @@ using System.Collections.Generic;
 namespace QuantConnect.Algorithm.CSharp
 {
     /// <summary>
-    /// Basic template algorithm for the Atreyu brokerage
+    /// Basic template algorithm for the Axos brokerage
     /// </summary>
     /// <meta name="tag" content="using data" />
     /// <meta name="tag" content="using quantconnect" />
     /// <meta name="tag" content="trading and orders" />
-    public class BasicTemplateAtreyuAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    public class BasicTemplateAxosAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
     {
         /// <summary>
         /// Initialise the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must initialized.
@@ -38,14 +37,8 @@ namespace QuantConnect.Algorithm.CSharp
             SetEndDate(2013, 10, 11);
             SetCash(100000);
 
-            SetBrokerageModel(BrokerageName.Atreyu);
+            SetBrokerageModel(BrokerageName.Axos);
             AddEquity("SPY", Resolution.Minute);
-
-            DefaultOrderProperties = new AtreyuOrderProperties
-            {
-                // Currently only support order for the day
-                TimeInForce = TimeInForce.Day
-            };
         }
 
         /// <summary>
@@ -95,7 +88,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "0.500%"},
             {"Expectancy", "0"},
             {"Net Profit", "0.423%"},
-            {"Sharpe Ratio", "5.634"},
+            {"Sharpe Ratio", "5.498"},
+            {"Sortino Ratio", "0"},
             {"Probabilistic Sharpe Ratio", "67.498%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
@@ -110,26 +104,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Fees", "$0.60"},
             {"Estimated Strategy Capacity", "$150000000.00"},
             {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
-            {"Fitness Score", "0.062"},
-            {"Kelly Criterion Estimate", "0"},
-            {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "71.634"},
-            {"Portfolio Turnover", "0.062"},
-            {"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", "d549c64ee7f5e3866712b3c7dbd64caa"}
+            {"Portfolio Turnover", "4.98%"},
+            {"OrderListHash", "c198b0d9bf2b4c41d69c7ea4750f09b5"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateContinuousFutureAlgorithm.cs

@@ -51,7 +51,7 @@ namespace QuantConnect.Algorithm.CSharp
                 contractDepthOffset: 0
             );
 
-            _fast = SMA(_continuousContract.Symbol, 3, Resolution.Daily);
+            _fast = SMA(_continuousContract.Symbol, 4, Resolution.Daily);
             _slow = SMA(_continuousContract.Symbol, 10, Resolution.Daily);
         }
 
@@ -118,7 +118,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 284403;
+        public long DataPoints => 713394;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -130,48 +130,31 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
-            {"Total Trades", "2"},
-            {"Average Win", "0%"},
-            {"Average Loss", "-0.02%"},
-            {"Compounding Annual Return", "-0.033%"},
-            {"Drawdown", "0.000%"},
-            {"Expectancy", "-1"},
-            {"Net Profit", "-0.017%"},
-            {"Sharpe Ratio", "-1.173"},
-            {"Probabilistic Sharpe Ratio", "0.011%"},
-            {"Loss Rate", "100%"},
-            {"Win Rate", "0%"},
+            {"Total Trades", "5"},
+            {"Average Win", "2.90%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "13.087%"},
+            {"Drawdown", "1.100%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "6.387%"},
+            {"Sharpe Ratio", "1.532"},
+            {"Sortino Ratio", "871.704"},
+            {"Probabilistic Sharpe Ratio", "90.613%"},
+            {"Loss Rate", "0%"},
+            {"Win Rate", "100%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "-0"},
-            {"Beta", "-0"},
-            {"Annual Standard Deviation", "0"},
-            {"Annual Variance", "0"},
-            {"Information Ratio", "-2.752"},
-            {"Tracking Error", "0.082"},
-            {"Treynor Ratio", "1.883"},
-            {"Total Fees", "$4.30"},
-            {"Estimated Strategy Capacity", "$0"},
+            {"Alpha", "0.088"},
+            {"Beta", "-0.022"},
+            {"Annual Standard Deviation", "0.054"},
+            {"Annual Variance", "0.003"},
+            {"Information Ratio", "-1.35"},
+            {"Tracking Error", "0.1"},
+            {"Treynor Ratio", "-3.781"},
+            {"Total Fees", "$10.75"},
+            {"Estimated Strategy Capacity", "$1100000000.00"},
             {"Lowest Capacity Asset", "ES VMKLFZIH2MTD"},
-            {"Fitness Score", "0.006"},
-            {"Kelly Criterion Estimate", "0"},
-            {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "-1.993"},
-            {"Portfolio Turnover", "0.01"},
-            {"Total Insights Generated", "0"},
-            {"Total Insights Closed", "0"},
-            {"Total Insights Analysis Completed", "0"},
-            {"Long Insight Count", "0"},
-            {"Short Insight Count", "0"},
-            {"Long/Short Ratio", "100%"},
-            {"Estimated Monthly Alpha Value", "$0"},
-            {"Total Accumulated Estimated Alpha Value", "$0"},
-            {"Mean Population Estimated Insight Value", "$0"},
-            {"Mean Population Direction", "0%"},
-            {"Mean Population Magnitude", "0%"},
-            {"Rolling Averaged Population Direction", "0%"},
-            {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "1fd4b49e9450800981c6dead2bbca995"}
+            {"Portfolio Turnover", "2.32%"},
+            {"OrderListHash", "c42bb4b319557346b155cd2c06ade894"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateContinuousFutureWithExtendedMarketAlgorithm.cs

@@ -52,7 +52,7 @@ namespace QuantConnect.Algorithm.CSharp
                 extendedMarketHours: true
             );
 
-            _fast = SMA(_continuousContract.Symbol, 3, Resolution.Daily);
+            _fast = SMA(_continuousContract.Symbol, 4, Resolution.Daily);
             _slow = SMA(_continuousContract.Symbol, 10, Resolution.Daily);
         }
 
@@ -123,7 +123,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 884815;
+        public long DataPoints => 2217324;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -135,48 +135,31 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
-            {"Total Trades", "2"},
-            {"Average Win", "0%"},
-            {"Average Loss", "-0.02%"},
-            {"Compounding Annual Return", "-0.033%"},
-            {"Drawdown", "0.000%"},
-            {"Expectancy", "-1"},
-            {"Net Profit", "-0.017%"},
-            {"Sharpe Ratio", "-1.173"},
-            {"Probabilistic Sharpe Ratio", "0.011%"},
-            {"Loss Rate", "100%"},
-            {"Win Rate", "0%"},
-            {"Profit-Loss Ratio", "0"},
-            {"Alpha", "-0"},
-            {"Beta", "-0"},
-            {"Annual Standard Deviation", "0"},
-            {"Annual Variance", "0"},
-            {"Information Ratio", "-2.752"},
-            {"Tracking Error", "0.082"},
-            {"Treynor Ratio", "1.883"},
-            {"Total Fees", "$4.30"},
-            {"Estimated Strategy Capacity", "$0"},
+            {"Total Trades", "5"},
+            {"Average Win", "4.45%"},
+            {"Average Loss", "-0.26%"},
+            {"Compounding Annual Return", "8.423%"},
+            {"Drawdown", "0.800%"},
+            {"Expectancy", "8.202"},
+            {"Net Profit", "4.162%"},
+            {"Sharpe Ratio", "0.951"},
+            {"Sortino Ratio", "2.8"},
+            {"Probabilistic Sharpe Ratio", "53.568%"},
+            {"Loss Rate", "50%"},
+            {"Win Rate", "50%"},
+            {"Profit-Loss Ratio", "17.40"},
+            {"Alpha", "0.053"},
+            {"Beta", "-0.005"},
+            {"Annual Standard Deviation", "0.054"},
+            {"Annual Variance", "0.003"},
+            {"Information Ratio", "-1.681"},
+            {"Tracking Error", "0.099"},
+            {"Treynor Ratio", "-10.255"},
+            {"Total Fees", "$10.75"},
+            {"Estimated Strategy Capacity", "$190000000.00"},
             {"Lowest Capacity Asset", "ES VMKLFZIH2MTD"},
-            {"Fitness Score", "0.006"},
-            {"Kelly Criterion Estimate", "0"},
-            {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "-1.985"},
-            {"Portfolio Turnover", "0.01"},
-            {"Total Insights Generated", "0"},
-            {"Total Insights Closed", "0"},
-            {"Total Insights Analysis Completed", "0"},
-            {"Long Insight Count", "0"},
-            {"Short Insight Count", "0"},
-            {"Long/Short Ratio", "100%"},
-            {"Estimated Monthly Alpha Value", "$0"},
-            {"Total Accumulated Estimated Alpha Value", "$0"},
-            {"Mean Population Estimated Insight Value", "$0"},
-            {"Mean Population Direction", "0%"},
-            {"Mean Population Magnitude", "0%"},
-            {"Rolling Averaged Population Direction", "0%"},
-            {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "adb237703e65b93da5961c0085109732"}
+            {"Portfolio Turnover", "2.34%"},
+            {"OrderListHash", "8a6ad6061fc3c311934a0801c26744eb"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateCryptoAlgorithm.cs

@@ -201,7 +201,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 12970;
+        public long DataPoints => 12965;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -221,6 +221,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Expectancy", "0"},
             {"Net Profit", "0%"},
             {"Sharpe Ratio", "0"},
+            {"Sortino Ratio", "0"},
             {"Probabilistic Sharpe Ratio", "0%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
@@ -234,27 +235,9 @@ namespace QuantConnect.Algorithm.CSharp
             {"Treynor Ratio", "0"},
             {"Total Fees", "$85.34"},
             {"Estimated Strategy Capacity", "$0"},
-            {"Lowest Capacity Asset", "BTCEUR XJ"},
-            {"Fitness Score", "0.5"},
-            {"Kelly Criterion Estimate", "0"},
-            {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "-43.943"},
-            {"Portfolio Turnover", "1.028"},
-            {"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", "1bf1a6d9dd921982b72a6178f9e50e68"}
+            {"Lowest Capacity Asset", "BTCEUR 2XR"},
+            {"Portfolio Turnover", "118.08%"},
+            {"OrderListHash", "77458586d24f1cd00623d63da8279be2"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateCryptoFutureAlgorithm.cs

@@ -0,0 +1,275 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
+using System;
+using QuantConnect.Data;
+using QuantConnect.Orders;
+using QuantConnect.Brokerages;
+using QuantConnect.Indicators;
+using QuantConnect.Interfaces;
+using QuantConnect.Securities;
+using QuantConnect.Data.Market;
+using System.Collections.Generic;
+using QuantConnect.Securities.CryptoFuture;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Minute resolution regression algorithm trading Coin and USDT binance futures long and short asserting the behavior
+    /// </summary>
+    public class BasicTemplateCryptoFutureAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Dictionary<Symbol, int> _interestPerSymbol = new();
+        private CryptoFuture _btcUsd;
+        private CryptoFuture _adaUsdt;
+        private ExponentialMovingAverage _fast;
+        private ExponentialMovingAverage _slow;
+
+        /// <summary>
+        /// Initialise the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must initialized.
+        /// </summary>
+        public override void Initialize()
+        {
+            SetStartDate(2022, 12, 13); // Set Start Date
+            SetEndDate(2022, 12, 13); // Set End Date
+
+            SetTimeZone(TimeZones.Utc);
+
+            try
+            {
+                SetBrokerageModel(BrokerageName.BinanceFutures, AccountType.Cash);
+            }
+            catch (InvalidOperationException)
+            {
+                // expected, we don't allow cash account type
+            }
+            SetBrokerageModel(BrokerageName.BinanceFutures, AccountType.Margin);
+
+            _btcUsd = AddCryptoFuture("BTCUSD");
+            _adaUsdt = AddCryptoFuture("ADAUSDT");
+
+            _fast = EMA(_btcUsd.Symbol, 30, Resolution.Minute);
+            _slow = EMA(_btcUsd.Symbol, 60, Resolution.Minute);
+
+            _interestPerSymbol[_btcUsd.Symbol] = 0;
+            _interestPerSymbol[_adaUsdt.Symbol] = 0;
+
+            // Default USD cash, set 1M but it wont be used
+            SetCash(1000000);
+
+            // the amount of BTC we need to hold to trade 'BTCUSD'
+            _btcUsd.BaseCurrency.SetAmount(0.005m);
+            // the amount of USDT we need to hold to trade 'ADAUSDT'
+            _adaUsdt.QuoteCurrency.SetAmount(200);
+        }
+
+        /// <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 interestRates = data.Get<MarginInterestRate>();
+            foreach (var interestRate in interestRates)
+            {
+                _interestPerSymbol[interestRate.Key]++;
+
+                var cachedInterestRate = Securities[interestRate.Key].Cache.GetData<MarginInterestRate>();
+                if (cachedInterestRate != interestRate.Value)
+                {
+                    throw new Exception($"Unexpected cached margin interest rate for {interestRate.Key}!");
+                }
+            }
+
+            if (_fast > _slow)
+            {
+                if (!Portfolio.Invested && Transactions.OrdersCount == 0)
+                {
+                    var ticket = Buy(_btcUsd.Symbol, 50);
+                    if (ticket.Status != OrderStatus.Invalid)
+                    {
+                        throw new Exception($"Unexpected valid order {ticket}, should fail due to margin not sufficient");
+                    }
+
+                    Buy(_btcUsd.Symbol, 1);
+
+                    var marginUsed = Portfolio.TotalMarginUsed;
+                    var btcUsdHoldings = _btcUsd.Holdings;
+
+                    // Coin futures value is 100 USD
+                    var holdingsValueBtcUsd = 100;
+
+                    if (Math.Abs(btcUsdHoldings.TotalSaleVolume - holdingsValueBtcUsd) > 1)
+                    {
+                        throw new Exception($"Unexpected TotalSaleVolume {btcUsdHoldings.TotalSaleVolume}");
+                    }
+                    if (Math.Abs(btcUsdHoldings.AbsoluteHoldingsCost - holdingsValueBtcUsd) > 1)
+                    {
+                        throw new Exception($"Unexpected holdings cost {btcUsdHoldings.HoldingsCost}");
+                    }
+                    // margin used is based on the maintenance rate
+                    if (Math.Abs(btcUsdHoldings.AbsoluteHoldingsCost * 0.05m - marginUsed) > 1
+                        || _btcUsd.BuyingPowerModel.GetMaintenanceMargin(_btcUsd) != marginUsed)
+                    {
+                        throw new Exception($"Unexpected margin used {marginUsed}");
+                    }
+
+                    Buy(_adaUsdt.Symbol, 1000);
+
+                    marginUsed = Portfolio.TotalMarginUsed - marginUsed;
+                    var adaUsdtHoldings = _adaUsdt.Holdings;
+
+                    // USDT/BUSD futures value is based on it's price
+                    var holdingsValueUsdt = _adaUsdt.Price * _adaUsdt.SymbolProperties.ContractMultiplier * 1000;
+
+                    if (Math.Abs(adaUsdtHoldings.TotalSaleVolume - holdingsValueUsdt) > 1)
+                    {
+                        throw new Exception($"Unexpected TotalSaleVolume {adaUsdtHoldings.TotalSaleVolume}");
+                    }
+                    if (Math.Abs(adaUsdtHoldings.AbsoluteHoldingsCost - holdingsValueUsdt) > 1)
+                    {
+                        throw new Exception($"Unexpected holdings cost {adaUsdtHoldings.HoldingsCost}");
+                    }
+                    if (Math.Abs(adaUsdtHoldings.AbsoluteHoldingsCost * 0.05m - marginUsed) > 1
+                        || _adaUsdt.BuyingPowerModel.GetMaintenanceMargin(_adaUsdt) != marginUsed)
+                    {
+                        throw new Exception($"Unexpected margin used {marginUsed}");
+                    }
+
+                    // position just opened should be just spread here
+                    var profit = Portfolio.TotalUnrealizedProfit;
+                    if ((5 - Math.Abs(profit)) < 0)
+                    {
+                        throw new Exception($"Unexpected TotalUnrealizedProfit {Portfolio.TotalUnrealizedProfit}");
+                    }
+
+                    if (Portfolio.TotalProfit != 0)
+                    {
+                        throw new Exception($"Unexpected TotalProfit {Portfolio.TotalProfit}");
+                    }
+                }
+            }
+            else
+            {
+                // let's revert our position and double
+                if (Time.Hour > 10 && Transactions.OrdersCount == 3)
+                {
+                    Sell(_btcUsd.Symbol, 3);
+
+                    var btcUsdHoldings = _btcUsd.Holdings;
+
+                    if (Math.Abs(btcUsdHoldings.AbsoluteHoldingsCost - 100 * 2) > 1)
+                    {
+                        throw new Exception($"Unexpected holdings cost {btcUsdHoldings.HoldingsCost}");
+                    }
+
+                    Sell(_adaUsdt.Symbol, 3000);
+
+                    var adaUsdtHoldings = _adaUsdt.Holdings;
+
+                    // USDT/BUSD futures value is based on it's price
+                    var holdingsValueUsdt = _adaUsdt.Price * _adaUsdt.SymbolProperties.ContractMultiplier * 2000;
+
+                    if (Math.Abs(adaUsdtHoldings.AbsoluteHoldingsCost - holdingsValueUsdt) > 1)
+                    {
+                        throw new Exception($"Unexpected holdings cost {adaUsdtHoldings.HoldingsCost}");
+                    }
+
+                    // position just opened should be just spread here
+                    var profit = Portfolio.TotalUnrealizedProfit;
+                    if ((5 - Math.Abs(profit)) < 0)
+                    {
+                        throw new Exception($"Unexpected TotalUnrealizedProfit {Portfolio.TotalUnrealizedProfit}");
+                    }
+                    // we barely did any difference on the previous trade
+                    if ((5 - Math.Abs(Portfolio.TotalProfit)) < 0)
+                    {
+                        throw new Exception($"Unexpected TotalProfit {Portfolio.TotalProfit}");
+                    }
+                }
+            }
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            if (_interestPerSymbol[_adaUsdt.Symbol] != 1)
+            {
+                throw new Exception($"Unexpected interest rate count {_interestPerSymbol[_adaUsdt.Symbol]}");
+            }
+
+            if (_interestPerSymbol[_btcUsd.Symbol] != 3)
+            {
+                throw new Exception($"Unexpected interest rate count {_interestPerSymbol[_btcUsd.Symbol]}");
+            }
+        }
+
+        public override void OnOrderEvent(OrderEvent orderEvent)
+        {
+            Debug(Time + " " + orderEvent);
+        }
+
+        /// <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>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 7205;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public int AlgorithmHistoryDataPoints => 0;
+
+        /// <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", "0%"},
+            {"Drawdown", "0%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "0%"},
+            {"Sharpe Ratio", "0"},
+            {"Sortino 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.65"},
+            {"Estimated Strategy Capacity", "$500000000.00"},
+            {"Lowest Capacity Asset", "ADAUSDT 18R"},
+            {"Portfolio Turnover", "0.16%"},
+            {"OrderListHash", "ed329700a93491ffe30354769767c6aa"}
+        };
+    }
+}

Algorithm.CSharp/BasicTemplateCryptoFutureHourlyAlgorithm.cs

@@ -0,0 +1,238 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
+using System;
+using QuantConnect.Data;
+using QuantConnect.Orders;
+using QuantConnect.Indicators;
+using QuantConnect.Interfaces;
+using QuantConnect.Securities;
+using QuantConnect.Brokerages;
+using QuantConnect.Data.Market;
+using System.Collections.Generic;
+using QuantConnect.Securities.CryptoFuture;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Hourly regression algorithm trading ADAUSDT binance futures long and short asserting the behavior
+    /// </summary>
+    public class BasicTemplateCryptoFutureHourlyAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Dictionary<Symbol, int> _interestPerSymbol = new();
+        private CryptoFuture _adaUsdt;
+        private ExponentialMovingAverage _fast;
+        private ExponentialMovingAverage _slow;
+
+        /// <summary>
+        /// Initialise the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must initialized.
+        /// </summary>
+        public override void Initialize()
+        {
+            SetStartDate(2022, 12, 13);
+            SetEndDate(2022, 12, 13);
+
+            SetTimeZone(TimeZones.Utc);
+
+            try
+            {
+                SetBrokerageModel(BrokerageName.BinanceCoinFutures, AccountType.Cash);
+            }
+            catch (InvalidOperationException)
+            {
+                // expected, we don't allow cash account type
+            }
+            SetBrokerageModel(BrokerageName.BinanceCoinFutures, AccountType.Margin);
+
+            _adaUsdt = AddCryptoFuture("ADAUSDT", Resolution.Hour);
+
+            _fast = EMA(_adaUsdt.Symbol, 3, Resolution.Hour);
+            _slow = EMA(_adaUsdt.Symbol, 6, Resolution.Hour);
+
+            _interestPerSymbol[_adaUsdt.Symbol] = 0;
+
+            // Default USD cash, set 1M but it wont be used
+            SetCash(1000000);
+
+            // the amount of USDT we need to hold to trade 'ADAUSDT'
+            _adaUsdt.QuoteCurrency.SetAmount(200);
+        }
+
+        /// <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 interestRates = data.Get<MarginInterestRate>();
+            foreach (var interestRate in interestRates)
+            {
+                _interestPerSymbol[interestRate.Key]++;
+
+                var cachedInterestRate = Securities[interestRate.Key].Cache.GetData<MarginInterestRate>();
+                if (cachedInterestRate != interestRate.Value)
+                {
+                    throw new Exception($"Unexpected cached margin interest rate for {interestRate.Key}!");
+                }
+            }
+
+            if (_fast > _slow)
+            {
+                if (!Portfolio.Invested && Transactions.OrdersCount == 0)
+                {
+                    var ticket = Buy(_adaUsdt.Symbol, 100000);
+                    if(ticket.Status != OrderStatus.Invalid)
+                    {
+                        throw new Exception($"Unexpected valid order {ticket}, should fail due to margin not sufficient");
+                    }
+
+                    Buy(_adaUsdt.Symbol, 1000);
+
+                    var marginUsed = Portfolio.TotalMarginUsed;
+                    var adaUsdtHoldings = _adaUsdt.Holdings;
+
+                    // USDT/BUSD futures value is based on it's price
+                    var holdingsValueUsdt = _adaUsdt.Price * _adaUsdt.SymbolProperties.ContractMultiplier * 1000;
+
+                    if (Math.Abs(adaUsdtHoldings.TotalSaleVolume - holdingsValueUsdt) > 1)
+                    {
+                        throw new Exception($"Unexpected TotalSaleVolume {adaUsdtHoldings.TotalSaleVolume}");
+                    }
+                    if (Math.Abs(adaUsdtHoldings.AbsoluteHoldingsCost - holdingsValueUsdt) > 1)
+                    {
+                        throw new Exception($"Unexpected holdings cost {adaUsdtHoldings.HoldingsCost}");
+                    }
+                    if (Math.Abs(adaUsdtHoldings.AbsoluteHoldingsCost * 0.05m - marginUsed) > 1
+                        || _adaUsdt.BuyingPowerModel.GetMaintenanceMargin(_adaUsdt) != marginUsed)
+                    {
+                        throw new Exception($"Unexpected margin used {marginUsed}");
+                    }
+
+                    // position just opened should be just spread here
+                    var profit = Portfolio.TotalUnrealizedProfit;
+                    if ((5 - Math.Abs(profit)) < 0)
+                    {
+                        throw new Exception($"Unexpected TotalUnrealizedProfit {Portfolio.TotalUnrealizedProfit}");
+                    }
+
+                    if (Portfolio.TotalProfit != 0)
+                    {
+                        throw new Exception($"Unexpected TotalProfit {Portfolio.TotalProfit}");
+                    }
+                }
+            }
+            else
+            {
+                // let's revert our position and double
+                if (Time.Hour > 10 && Transactions.OrdersCount == 2)
+                {
+                    Sell(_adaUsdt.Symbol, 3000);
+
+                    var adaUsdtHoldings = _adaUsdt.Holdings;
+
+                    // USDT/BUSD futures value is based on it's price
+                    var holdingsValueUsdt = _adaUsdt.Price * _adaUsdt.SymbolProperties.ContractMultiplier * 2000;
+
+                    if (Math.Abs(adaUsdtHoldings.AbsoluteHoldingsCost - holdingsValueUsdt) > 1)
+                    {
+                        throw new Exception($"Unexpected holdings cost {adaUsdtHoldings.HoldingsCost}");
+                    }
+
+                    // position just opened should be just spread here
+                    var profit = Portfolio.TotalUnrealizedProfit;
+                    if ((5 - Math.Abs(profit)) < 0)
+                    {
+                        throw new Exception($"Unexpected TotalUnrealizedProfit {Portfolio.TotalUnrealizedProfit}");
+                    }
+                    // we barely did any difference on the previous trade
+                    if ((5 - Math.Abs(Portfolio.TotalProfit)) < 0)
+                    {
+                        throw new Exception($"Unexpected TotalProfit {Portfolio.TotalProfit}");
+                    }
+                }
+
+                if (Time.Hour >= 22 && Transactions.OrdersCount == 3)
+                {
+                    Liquidate();
+                }
+            }
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            if (_interestPerSymbol[_adaUsdt.Symbol] != 1)
+            {
+                throw new Exception($"Unexpected interest rate count {_interestPerSymbol[_adaUsdt.Symbol]}");
+            }
+        }
+
+        public override void OnOrderEvent(OrderEvent orderEvent)
+        {
+            Debug(Time + " " + orderEvent);
+        }
+
+        /// <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>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 50;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public int AlgorithmHistoryDataPoints => 0;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        {
+            {"Total Trades", "2"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "0%"},
+            {"Drawdown", "0%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "0%"},
+            {"Sharpe Ratio", "0"},
+            {"Sortino 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.61"},
+            {"Estimated Strategy Capacity", "$370000000.00"},
+            {"Lowest Capacity Asset", "ADAUSDT 18R"},
+            {"Portfolio Turnover", "0.12%"},
+            {"OrderListHash", "5b1290390c34b0e64ac0b9e834c27b07"}
+        };
+    }
+}

Algorithm.CSharp/BasicTemplateDailyAlgorithm.cs

@@ -85,7 +85,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "1.200%"},
             {"Expectancy", "0"},
             {"Net Profit", "3.464%"},
-            {"Sharpe Ratio", "19.148"},
+            {"Sharpe Ratio", "19.094"},
+            {"Sortino Ratio", "0"},
             {"Probabilistic Sharpe Ratio", "97.754%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
@@ -96,30 +97,12 @@ namespace QuantConnect.Algorithm.CSharp
             {"Annual Variance", "0.019"},
             {"Information Ratio", "-34.028"},
             {"Tracking Error", "0"},
-            {"Treynor Ratio", "2.651"},
+            {"Treynor Ratio", "2.644"},
             {"Total Fees", "$3.45"},
             {"Estimated Strategy Capacity", "$970000000.00"},
             {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
-            {"Fitness Score", "0.112"},
-            {"Kelly Criterion Estimate", "0"},
-            {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "53.951"},
-            {"Return Over Maximum Drawdown", "209.464"},
-            {"Portfolio Turnover", "0.112"},
-            {"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", "33d01821923c397f999cfb2e5b5928ad"}
+            {"Portfolio Turnover", "10.09%"},
+            {"OrderListHash", "418c8ec9920ec61bdefa2d02a8557048"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateFrameworkAlgorithm.cs

@@ -106,7 +106,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "2.200%"},
             {"Expectancy", "-1"},
             {"Net Profit", "1.655%"},
-            {"Sharpe Ratio", "8.505"},
+            {"Sharpe Ratio", "8.472"},
+            {"Sortino Ratio", "0"},
             {"Probabilistic Sharpe Ratio", "66.840%"},
             {"Loss Rate", "100%"},
             {"Win Rate", "0%"},
@@ -117,30 +118,12 @@ namespace QuantConnect.Algorithm.CSharp
             {"Annual Variance", "0.05"},
             {"Information Ratio", "-33.445"},
             {"Tracking Error", "0.002"},
-            {"Treynor Ratio", "1.893"},
+            {"Treynor Ratio", "1.885"},
             {"Total Fees", "$10.32"},
             {"Estimated Strategy Capacity", "$27000000.00"},
             {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
-            {"Fitness Score", "0.747"},
-            {"Kelly Criterion Estimate", "38.796"},
-            {"Kelly Criterion Probability Value", "0.228"},
-            {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "85.095"},
-            {"Portfolio Turnover", "0.747"},
-            {"Total Insights Generated", "100"},
-            {"Total Insights Closed", "99"},
-            {"Total Insights Analysis Completed", "99"},
-            {"Long Insight Count", "100"},
-            {"Short Insight Count", "0"},
-            {"Long/Short Ratio", "100%"},
-            {"Estimated Monthly Alpha Value", "$135639.1761"},
-            {"Total Accumulated Estimated Alpha Value", "$21852.9784"},
-            {"Mean Population Estimated Insight Value", "$220.7372"},
-            {"Mean Population Direction", "53.5354%"},
-            {"Mean Population Magnitude", "53.5354%"},
-            {"Rolling Averaged Population Direction", "58.2788%"},
-            {"Rolling Averaged Population Magnitude", "58.2788%"},
-            {"OrderListHash", "ad2216297c759d8e5aef48ff065f8919"}
+            {"Portfolio Turnover", "59.86%"},
+            {"OrderListHash", "75c4c7221e2e70d0aa5c9844aae9009c"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateFutureRolloverAlgorithm.cs

@@ -0,0 +1,218 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+
+using System.Collections.Generic;
+using QuantConnect.Data;
+using QuantConnect.Interfaces;
+using QuantConnect.Indicators;
+using QuantConnect.Securities;
+using QuantConnect.Securities.Future;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Example algorithm for trading continuous future
+    /// </summary>
+    public class BasicTemplateFutureRolloverAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Dictionary<Symbol, SymbolData> _symbolDataBySymbol = new();
+
+        /// <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, 8);
+            SetEndDate(2013, 12, 10);
+            SetCash(1000000);
+
+            var futures = new List<string> {
+                Futures.Indices.SP500EMini
+            };
+
+            foreach (var future in futures)
+            {
+                // Requesting data
+                var continuousContract = AddFuture(future,
+                    resolution: Resolution.Daily,
+                    extendedMarketHours: true,
+                    dataNormalizationMode: DataNormalizationMode.BackwardsRatio,
+                    dataMappingMode: DataMappingMode.OpenInterest,
+                    contractDepthOffset: 0
+                );
+
+                var symbolData = new SymbolData(this, continuousContract);
+                _symbolDataBySymbol.Add(continuousContract.Symbol, symbolData);
+            }
+        }
+
+        /// <summary>
+        /// OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here.
+        /// </summary>
+        /// <param name="slice">Slice object keyed by symbol containing the stock data</param>
+        public override void OnData(Slice slice)
+        {
+            foreach (var kvp in _symbolDataBySymbol)
+            {
+                var symbol = kvp.Key;
+                var symbolData = kvp.Value;
+
+                // Call SymbolData.Update() method to handle new data slice received
+                symbolData.Update(slice);
+
+                // Check if information in SymbolData class and new slice data are ready for trading
+                if (!symbolData.IsReady || !slice.Bars.ContainsKey(symbol))
+                {
+                    return;
+                }
+
+                var emaCurrentValue = symbolData.EMA.Current.Value;
+                if (emaCurrentValue < symbolData.Price && !symbolData.IsLong)
+                {
+                    MarketOrder(symbolData.Mapped, 1);
+                }
+                else if (emaCurrentValue > symbolData.Price && !symbolData.IsShort)
+                {
+                    MarketOrder(symbolData.Mapped, -1);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Abstracted class object to hold information (state, indicators, methods, etc.) from a Symbol/Security in a multi-security algorithm
+        /// </summary>
+        public class SymbolData
+        {
+            private QCAlgorithm _algorithm;
+            private Future _future;
+            public ExponentialMovingAverage EMA;
+            public decimal Price;
+            public bool IsLong;
+            public bool IsShort;
+            public Symbol Symbol => _future.Symbol;
+            public Symbol Mapped => _future.Mapped;
+
+            /// <summary>
+            /// Check if symbolData class object are ready for trading
+            /// </summary>
+            public bool IsReady => Mapped != null && EMA.IsReady;
+
+            /// <summary>
+            /// Constructor to instantiate the information needed to be hold
+            /// </summary>
+            public SymbolData(QCAlgorithm algorithm, Future future)
+            {
+                _algorithm = algorithm;
+                _future = future;
+                EMA = algorithm.EMA(future.Symbol, 20, Resolution.Daily);
+
+                Reset();
+            }
+
+            /// <summary>
+            /// Handler of new slice of data received
+            /// </summary>
+            public void Update(Slice slice)
+            {
+                if (slice.SymbolChangedEvents.TryGetValue(Symbol, out var changedEvent))
+                {
+                    var oldSymbol = changedEvent.OldSymbol;
+                    var newSymbol = changedEvent.NewSymbol;
+                    var tag = $"Rollover - Symbol changed at {_algorithm.Time}: {oldSymbol} -> {newSymbol}";
+                    var quantity = _algorithm.Portfolio[oldSymbol].Quantity;
+
+                    // Rolling over: to liquidate any position of the old mapped contract and switch to the newly mapped contract
+                    _algorithm.Liquidate(oldSymbol, tag: tag);
+                    _algorithm.MarketOrder(newSymbol, quantity, tag: tag);
+
+                    Reset();
+                }
+
+                Price = slice.Bars.ContainsKey(Symbol) ? slice.Bars[Symbol].Price : Price;
+                IsLong = _algorithm.Portfolio[Mapped].IsLong;
+                IsShort = _algorithm.Portfolio[Mapped].IsShort;
+            }
+
+            /// <summary>
+            /// Reset RollingWindow/indicator to adapt to newly mapped contract, then warm up the RollingWindow/indicator
+            /// </summary>
+            private void Reset()
+            {
+                EMA.Reset();
+                _algorithm.WarmUpIndicator(Symbol, EMA, Resolution.Daily);
+            }
+
+            /// <summary>
+            /// Disposal method to remove consolidator/update method handler, and reset RollingWindow/indicator to free up memory and speed
+            /// </summary>
+            public void Dispose()
+            {
+                EMA.Reset();
+            }
+        }
+        /// <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>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 1333;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public int AlgorithmHistoryDataPoints => 4;
+
+        /// <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.53%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "3.011%"},
+            {"Drawdown", "0.000%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "0.528%"},
+            {"Sharpe Ratio", "1.285"},
+            {"Sortino Ratio", "0"},
+            {"Probabilistic Sharpe Ratio", "83.704%"},
+            {"Loss Rate", "0%"},
+            {"Win Rate", "100%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "0.015"},
+            {"Beta", "-0.004"},
+            {"Annual Standard Deviation", "0.011"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "-4.774"},
+            {"Tracking Error", "0.084"},
+            {"Treynor Ratio", "-3.121"},
+            {"Total Fees", "$4.30"},
+            {"Estimated Strategy Capacity", "$5900000000.00"},
+            {"Lowest Capacity Asset", "ES VMKLFZIH2MTD"},
+            {"Portfolio Turnover", "0.27%"},
+            {"OrderListHash", "9fb6d9433c29815301d818ccd7f3863f"}
+        };
+    }  
+}

Algorithm.CSharp/BasicTemplateFuturesAlgorithm.cs

@@ -151,7 +151,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 68645;
+        public long DataPoints => 75401;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -170,41 +170,24 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "4.400%"},
             {"Expectancy", "-0.724"},
             {"Net Profit", "-4.430%"},
-            {"Sharpe Ratio", "-31.389"},
+            {"Sharpe Ratio", "-31.63"},
+            {"Sortino Ratio", "-31.63"},
             {"Probabilistic Sharpe Ratio", "0%"},
             {"Loss Rate", "83%"},
             {"Win Rate", "17%"},
             {"Profit-Loss Ratio", "0.65"},
-            {"Alpha", "-3.059"},
+            {"Alpha", "-3.065"},
             {"Beta", "0.128"},
             {"Annual Standard Deviation", "0.031"},
             {"Annual Variance", "0.001"},
             {"Information Ratio", "-81.232"},
             {"Tracking Error", "0.212"},
-            {"Treynor Ratio", "-7.618"},
+            {"Treynor Ratio", "-7.677"},
             {"Total Fees", "$6237.00"},
             {"Estimated Strategy Capacity", "$14000.00"},
             {"Lowest Capacity Asset", "GC VOFJUCDY9XNH"},
-            {"Fitness Score", "0.001"},
-            {"Kelly Criterion Estimate", "0"},
-            {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "-58.725"},
-            {"Return Over Maximum Drawdown", "-32.073"},
-            {"Portfolio Turnover", "98.477"},
-            {"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", "8f92e1528c6477a156449fd1e86527e7"}
+            {"Portfolio Turnover", "9912.69%"},
+            {"OrderListHash", "398c0383a9ba3235f15ac472a7fbcb8a"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateFuturesDailyAlgorithm.cs

@@ -117,7 +117,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public virtual long DataPoints => 11709;
+        public virtual long DataPoints => 14036;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -129,48 +129,31 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public virtual Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
-            {"Total Trades", "118"},
-            {"Average Win", "0.09%"},
+            {"Total Trades", "128"},
+            {"Average Win", "0.26%"},
             {"Average Loss", "-0.01%"},
-            {"Compounding Annual Return", "-0.479%"},
-            {"Drawdown", "0.500%"},
-            {"Expectancy", "-0.835"},
-            {"Net Profit", "-0.483%"},
-            {"Sharpe Ratio", "-1.938"},
-            {"Probabilistic Sharpe Ratio", "0%"},
-            {"Loss Rate", "98%"},
-            {"Win Rate", "2%"},
-            {"Profit-Loss Ratio", "8.76"},
-            {"Alpha", "-0.003"},
-            {"Beta", "-0.001"},
-            {"Annual Standard Deviation", "0.002"},
+            {"Compounding Annual Return", "-0.071%"},
+            {"Drawdown", "0.400%"},
+            {"Expectancy", "-0.116"},
+            {"Net Profit", "-0.071%"},
+            {"Sharpe Ratio", "-1.999"},
+            {"Sortino Ratio", "-1.806"},
+            {"Probabilistic Sharpe Ratio", "10.091%"},
+            {"Loss Rate", "97%"},
+            {"Win Rate", "3%"},
+            {"Profit-Loss Ratio", "27.29"},
+            {"Alpha", "-0.008"},
+            {"Beta", "0.001"},
+            {"Annual Standard Deviation", "0.004"},
             {"Annual Variance", "0"},
-            {"Information Ratio", "-1.397"},
+            {"Information Ratio", "-1.367"},
             {"Tracking Error", "0.089"},
-            {"Treynor Ratio", "5.665"},
-            {"Total Fees", "$263.30"},
+            {"Treynor Ratio", "-5.445"},
+            {"Total Fees", "$285.44"},
             {"Estimated Strategy Capacity", "$1000.00"},
             {"Lowest Capacity Asset", "ES VRJST036ZY0X"},
-            {"Fitness Score", "0.01"},
-            {"Kelly Criterion Estimate", "0"},
-            {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "-1.059"},
-            {"Return Over Maximum Drawdown", "-0.992"},
-            {"Portfolio Turnover", "0.031"},
-            {"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", "b75b224669c374dcbacc33f946a1cc7c"}
+            {"Portfolio Turnover", "3.41%"},
+            {"OrderListHash", "1666cd6c277c6ea8b1b46d5dfa6bac9f"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateFuturesFrameworkAlgorithm.cs

@@ -136,7 +136,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public virtual long DataPoints => 43786;
+        public virtual long DataPoints => 57752;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -155,41 +155,24 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "4.100%"},
             {"Expectancy", "0"},
             {"Net Profit", "-2.169%"},
-            {"Sharpe Ratio", "-10.195"},
+            {"Sharpe Ratio", "-10.299"},
+            {"Sortino Ratio", "-10.299"},
             {"Probabilistic Sharpe Ratio", "0%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "-1.206"},
+            {"Alpha", "-1.212"},
             {"Beta", "0.238"},
             {"Annual Standard Deviation", "0.072"},
             {"Annual Variance", "0.005"},
             {"Information Ratio", "-15.404"},
             {"Tracking Error", "0.176"},
-            {"Treynor Ratio", "-3.077"},
+            {"Treynor Ratio", "-3.109"},
             {"Total Fees", "$4.62"},
             {"Estimated Strategy Capacity", "$17000000.00"},
             {"Lowest Capacity Asset", "GC VL5E74HP3EE5"},
-            {"Fitness Score", "0.006"},
-            {"Kelly Criterion Estimate", "-50.022"},
-            {"Kelly Criterion Probability Value", "0.711"},
-            {"Sortino Ratio", "-9.907"},
-            {"Return Over Maximum Drawdown", "-50.79"},
-            {"Portfolio Turnover", "0.54"},
-            {"Total Insights Generated", "5"},
-            {"Total Insights Closed", "4"},
-            {"Total Insights Analysis Completed", "4"},
-            {"Long Insight Count", "5"},
-            {"Short Insight Count", "0"},
-            {"Long/Short Ratio", "100%"},
-            {"Estimated Monthly Alpha Value", "$-4434.791"},
-            {"Total Accumulated Estimated Alpha Value", "$-720.6535"},
-            {"Mean Population Estimated Insight Value", "$-180.1634"},
-            {"Mean Population Direction", "25%"},
-            {"Mean Population Magnitude", "0%"},
-            {"Rolling Averaged Population Direction", "25%"},
-            {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "323b899ae80aa839e320806411665ce7"}
+            {"Portfolio Turnover", "43.23%"},
+            {"OrderListHash", "1daca8b4534258de0f1bf09214205b77"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateFuturesFrameworkWithExtendedMarketAlgorithm.cs

@@ -41,7 +41,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public override long DataPoints => 123753;
+        public override long DataPoints => 163392;
 
         /// <summary>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
@@ -55,41 +55,24 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "5.000%"},
             {"Expectancy", "0"},
             {"Net Profit", "-3.314%"},
-            {"Sharpe Ratio", "-6.303"},
+            {"Sharpe Ratio", "-6.359"},
+            {"Sortino Ratio", "-11.237"},
             {"Probabilistic Sharpe Ratio", "9.333%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "-1.465"},
+            {"Alpha", "-1.47"},
             {"Beta", "0.312"},
             {"Annual Standard Deviation", "0.134"},
             {"Annual Variance", "0.018"},
             {"Information Ratio", "-14.77"},
             {"Tracking Error", "0.192"},
-            {"Treynor Ratio", "-2.718"},
+            {"Treynor Ratio", "-2.742"},
             {"Total Fees", "$4.62"},
             {"Estimated Strategy Capacity", "$52000000.00"},
             {"Lowest Capacity Asset", "GC VL5E74HP3EE5"},
-            {"Fitness Score", "0.009"},
-            {"Kelly Criterion Estimate", "-112.972"},
-            {"Kelly Criterion Probability Value", "0.671"},
-            {"Sortino Ratio", "-8.421"},
-            {"Return Over Maximum Drawdown", "-35.2"},
-            {"Portfolio Turnover", "0.548"},
-            {"Total Insights Generated", "6"},
-            {"Total Insights Closed", "5"},
-            {"Total Insights Analysis Completed", "5"},
-            {"Long Insight Count", "6"},
-            {"Short Insight Count", "0"},
-            {"Long/Short Ratio", "100%"},
-            {"Estimated Monthly Alpha Value", "$-96.12923"},
-            {"Total Accumulated Estimated Alpha Value", "$-15.621"},
-            {"Mean Population Estimated Insight Value", "$-3.1242"},
-            {"Mean Population Direction", "0%"},
-            {"Mean Population Magnitude", "0%"},
-            {"Rolling Averaged Population Direction", "0%"},
-            {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "18ffd3a774c68da83d867e3b09e3e05d"}
+            {"Portfolio Turnover", "43.77%"},
+            {"OrderListHash", "ba6e16f476a2ddeeaab9c9091664f7a1"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateFuturesHistoryAlgorithm.cs

@@ -140,12 +140,12 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public virtual long DataPoints => 44184;
+        public virtual long DataPoints => 48688;
 
         /// <summary>
         /// Data Points count of the algorithm history
         /// </summary>
-        public virtual int AlgorithmHistoryDataPoints => 4818;
+        public virtual int AlgorithmHistoryDataPoints => 5305;
 
         /// <summary>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
@@ -160,6 +160,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Expectancy", "0"},
             {"Net Profit", "0%"},
             {"Sharpe Ratio", "0"},
+            {"Sortino Ratio", "0"},
             {"Probabilistic Sharpe Ratio", "0%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
@@ -174,25 +175,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Fees", "$0.00"},
             {"Estimated Strategy Capacity", "$0"},
             {"Lowest Capacity Asset", ""},
-            {"Fitness Score", "0"},
-            {"Kelly Criterion Estimate", "0"},
-            {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "79228162514264337593543950335"},
-            {"Portfolio Turnover", "0"},
-            {"Total Insights Generated", "0"},
-            {"Total Insights Closed", "0"},
-            {"Total Insights Analysis Completed", "0"},
-            {"Long Insight Count", "0"},
-            {"Short Insight Count", "0"},
-            {"Long/Short Ratio", "100%"},
-            {"Estimated Monthly Alpha Value", "$0"},
-            {"Total Accumulated Estimated Alpha Value", "$0"},
-            {"Mean Population Estimated Insight Value", "$0"},
-            {"Mean Population Direction", "0%"},
-            {"Mean Population Magnitude", "0%"},
-            {"Rolling Averaged Population Direction", "0%"},
-            {"Rolling Averaged Population Magnitude", "0%"},
+            {"Portfolio Turnover", "0%"},
             {"OrderListHash", "d41d8cd98f00b204e9800998ecf8427e"}
         };
     }

Algorithm.CSharp/BasicTemplateFuturesHistoryWithExtendedMarketHoursAlgorithm.cs

@@ -47,12 +47,12 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public override long DataPoints => 134096;
+        public override long DataPoints => 147769;
 
         /// <summary>
         /// Data Points count of the algorithm history
         /// </summary>
-        public override int AlgorithmHistoryDataPoints => 5539;
+        public override int AlgorithmHistoryDataPoints => 6112;
 
         /// <summary>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
@@ -67,6 +67,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Expectancy", "0"},
             {"Net Profit", "0%"},
             {"Sharpe Ratio", "0"},
+            {"Sortino Ratio", "0"},
             {"Probabilistic Sharpe Ratio", "0%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
@@ -81,25 +82,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Fees", "$0.00"},
             {"Estimated Strategy Capacity", "$0"},
             {"Lowest Capacity Asset", ""},
-            {"Fitness Score", "0"},
-            {"Kelly Criterion Estimate", "0"},
-            {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "79228162514264337593543950335"},
-            {"Portfolio Turnover", "0"},
-            {"Total Insights Generated", "0"},
-            {"Total Insights Closed", "0"},
-            {"Total Insights Analysis Completed", "0"},
-            {"Long Insight Count", "0"},
-            {"Short Insight Count", "0"},
-            {"Long/Short Ratio", "100%"},
-            {"Estimated Monthly Alpha Value", "$0"},
-            {"Total Accumulated Estimated Alpha Value", "$0"},
-            {"Mean Population Estimated Insight Value", "$0"},
-            {"Mean Population Direction", "0%"},
-            {"Mean Population Magnitude", "0%"},
-            {"Rolling Averaged Population Direction", "0%"},
-            {"Rolling Averaged Population Magnitude", "0%"},
+            {"Portfolio Turnover", "0%"},
             {"OrderListHash", "d41d8cd98f00b204e9800998ecf8427e"}
         };
     }

Algorithm.CSharp/BasicTemplateFuturesHourlyAlgorithm.cs

@@ -41,7 +41,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public override long DataPoints => 73252;
+        public override long DataPoints => 87391;
 
         /// <summary>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
@@ -55,41 +55,24 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "1.600%"},
             {"Expectancy", "-0.841"},
             {"Net Profit", "-1.622%"},
-            {"Sharpe Ratio", "-5.105"},
+            {"Sharpe Ratio", "-8.787"},
+            {"Sortino Ratio", "-5.428"},
             {"Probabilistic Sharpe Ratio", "0.000%"},
             {"Loss Rate", "96%"},
             {"Win Rate", "4%"},
             {"Profit-Loss Ratio", "3.21"},
-            {"Alpha", "-0.01"},
+            {"Alpha", "-0.018"},
             {"Beta", "-0.003"},
             {"Annual Standard Deviation", "0.002"},
             {"Annual Variance", "0"},
             {"Information Ratio", "-1.473"},
             {"Tracking Error", "0.089"},
-            {"Treynor Ratio", "3.179"},
+            {"Treynor Ratio", "5.593"},
             {"Total Fees", "$1456.18"},
-            {"Estimated Strategy Capacity", "$6000.00"},
+            {"Estimated Strategy Capacity", "$9000.00"},
             {"Lowest Capacity Asset", "ES VP274HSU1AF5"},
-            {"Fitness Score", "0.045"},
-            {"Kelly Criterion Estimate", "0"},
-            {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "-4.326"},
-            {"Return Over Maximum Drawdown", "-0.994"},
-            {"Portfolio Turnover", "0.205"},
-            {"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", "8842e0b890f721371ebf3c25328dee5b"}
+            {"Portfolio Turnover", "17.91%"},
+            {"OrderListHash", "19d70e24c5d0922d1557de4adbf60ab5"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateFuturesWithExtendedMarketAlgorithm.cs

@@ -151,7 +151,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 204087;
+        public long DataPoints => 224660;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -170,41 +170,24 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "13.900%"},
             {"Expectancy", "-0.824"},
             {"Net Profit", "-13.874%"},
-            {"Sharpe Ratio", "-19.202"},
+            {"Sharpe Ratio", "-19.346"},
+            {"Sortino Ratio", "-19.346"},
             {"Probabilistic Sharpe Ratio", "0%"},
             {"Loss Rate", "89%"},
             {"Win Rate", "11%"},
             {"Profit-Loss Ratio", "0.64"},
-            {"Alpha", "2.477"},
+            {"Alpha", "2.468"},
             {"Beta", "-0.215"},
             {"Annual Standard Deviation", "0.052"},
             {"Annual Variance", "0.003"},
             {"Information Ratio", "-58.37"},
             {"Tracking Error", "0.295"},
-            {"Treynor Ratio", "4.66"},
+            {"Treynor Ratio", "4.695"},
             {"Total Fees", "$19131.42"},
             {"Estimated Strategy Capacity", "$130000.00"},
             {"Lowest Capacity Asset", "GC VOFJUCDY9XNH"},
-            {"Fitness Score", "0.032"},
-            {"Kelly Criterion Estimate", "0"},
-            {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "-9.217"},
-            {"Return Over Maximum Drawdown", "-7.692"},
-            {"Portfolio Turnover", "304.869"},
-            {"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", "85cdd035d7c7a3da178d1c2dff31f1bd"}
+            {"Portfolio Turnover", "32523.20%"},
+            {"OrderListHash", "584fbdabd837921edc6a7e99759b9c66"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateFuturesWithExtendedMarketDailyAlgorithm.cs

@@ -43,55 +43,38 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public override long DataPoints => 13559;
+        public override long DataPoints => 16263;
 
         /// <summary>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
         /// </summary>
         public override Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
-            {"Total Trades", "152"},
-            {"Average Win", "0.09%"},
+            {"Total Trades", "156"},
+            {"Average Win", "0.31%"},
             {"Average Loss", "-0.01%"},
-            {"Compounding Annual Return", "-0.644%"},
-            {"Drawdown", "0.600%"},
-            {"Expectancy", "-0.872"},
-            {"Net Profit", "-0.649%"},
-            {"Sharpe Ratio", "-2.343"},
-            {"Probabilistic Sharpe Ratio", "0%"},
-            {"Loss Rate", "99%"},
-            {"Win Rate", "1%"},
-            {"Profit-Loss Ratio", "8.76"},
-            {"Alpha", "-0.004"},
+            {"Compounding Annual Return", "-0.024%"},
+            {"Drawdown", "0.400%"},
+            {"Expectancy", "-0.035"},
+            {"Net Profit", "-0.025%"},
+            {"Sharpe Ratio", "-1.602"},
+            {"Sortino Ratio", "-1.913"},
+            {"Probabilistic Sharpe Ratio", "11.172%"},
+            {"Loss Rate", "97%"},
+            {"Win Rate", "3%"},
+            {"Profit-Loss Ratio", "36.65"},
+            {"Alpha", "-0.007"},
             {"Beta", "-0.001"},
-            {"Annual Standard Deviation", "0.002"},
+            {"Annual Standard Deviation", "0.005"},
             {"Annual Variance", "0"},
-            {"Information Ratio", "-1.409"},
+            {"Information Ratio", "-1.359"},
             {"Tracking Error", "0.089"},
-            {"Treynor Ratio", "3.618"},
-            {"Total Fees", "$338.96"},
+            {"Treynor Ratio", "8.008"},
+            {"Total Fees", "$347.56"},
             {"Estimated Strategy Capacity", "$1000.00"},
             {"Lowest Capacity Asset", "ES VRJST036ZY0X"},
-            {"Fitness Score", "0.013"},
-            {"Kelly Criterion Estimate", "0"},
-            {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "-1.464"},
-            {"Return Over Maximum Drawdown", "-0.992"},
-            {"Portfolio Turnover", "0.04"},
-            {"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", "48bfc4d255420cb589e00cf582554e0a"}
+            {"Portfolio Turnover", "4.16%"},
+            {"OrderListHash", "ce63f5e611a7ab2f49d49c9fdc777ef5"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateFuturesWithExtendedMarketHourlyAlgorithm.cs

@@ -41,55 +41,38 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public override long DataPoints => 205645;
+        public override long DataPoints => 228936;
 
         /// <summary>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
         /// </summary>
         public override Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
-            {"Total Trades", "1982"},
+            {"Total Trades", "1990"},
             {"Average Win", "0.01%"},
             {"Average Loss", "-0.01%"},
-            {"Compounding Annual Return", "-4.666%"},
+            {"Compounding Annual Return", "-4.683%"},
             {"Drawdown", "4.700%"},
             {"Expectancy", "-0.911"},
-            {"Net Profit", "-4.700%"},
-            {"Sharpe Ratio", "-5.792"},
+            {"Net Profit", "-4.717%"},
+            {"Sharpe Ratio", "-7.178"},
+            {"Sortino Ratio", "-5.126"},
             {"Probabilistic Sharpe Ratio", "0%"},
             {"Loss Rate", "97%"},
             {"Win Rate", "3%"},
             {"Profit-Loss Ratio", "2.04"},
-            {"Alpha", "-0.031"},
+            {"Alpha", "-0.038"},
             {"Beta", "-0.008"},
             {"Annual Standard Deviation", "0.005"},
             {"Annual Variance", "0"},
-            {"Information Ratio", "-1.701"},
+            {"Information Ratio", "-1.702"},
             {"Tracking Error", "0.09"},
-            {"Treynor Ratio", "4.096"},
-            {"Total Fees", "$4521.78"},
-            {"Estimated Strategy Capacity", "$2000.00"},
+            {"Treynor Ratio", "5.049"},
+            {"Total Fees", "$4538.98"},
+            {"Estimated Strategy Capacity", "$3000.00"},
             {"Lowest Capacity Asset", "ES VP274HSU1AF5"},
-            {"Fitness Score", "0.131"},
-            {"Kelly Criterion Estimate", "0"},
-            {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "-6.211"},
-            {"Return Over Maximum Drawdown", "-0.995"},
-            {"Portfolio Turnover", "0.649"},
-            {"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", "2402a307b20aee195b77b8478d7ca64d"}
+            {"Portfolio Turnover", "56.68%"},
+            {"OrderListHash", "4ebc10fed9201f59aa7fcd90fbb49448"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateHourlyAlgorithm.cs

@@ -94,7 +94,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "2.000%"},
             {"Expectancy", "0"},
             {"Net Profit", "1.529%"},
-            {"Sharpe Ratio", "8.889"},
+            {"Sharpe Ratio", "8.855"},
+            {"Sortino Ratio", "0"},
             {"Probabilistic Sharpe Ratio", "67.609%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
@@ -105,30 +106,12 @@ namespace QuantConnect.Algorithm.CSharp
             {"Annual Variance", "0.049"},
             {"Information Ratio", "-14.564"},
             {"Tracking Error", "0.001"},
-            {"Treynor Ratio", "1.978"},
+            {"Treynor Ratio", "1.971"},
             {"Total Fees", "$3.44"},
             {"Estimated Strategy Capacity", "$110000000.00"},
             {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
-            {"Fitness Score", "0.247"},
-            {"Kelly Criterion Estimate", "0"},
-            {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "12.105"},
-            {"Return Over Maximum Drawdown", "112.047"},
-            {"Portfolio Turnover", "0.249"},
-            {"Total Insights Generated", "0"},
-            {"Total Insights Closed", "0"},
-            {"Total Insights Analysis Completed", "0"},
-            {"Long Insight Count", "0"},
-            {"Short Insight Count", "0"},
-            {"Long/Short Ratio", "100%"},
-            {"Estimated Monthly Alpha Value", "$0"},
-            {"Total Accumulated Estimated Alpha Value", "$0"},
-            {"Mean Population Estimated Insight Value", "$0"},
-            {"Mean Population Direction", "0%"},
-            {"Mean Population Magnitude", "0%"},
-            {"Rolling Averaged Population Direction", "0%"},
-            {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "f409be3a7c63d9c1394c2e6c005a15ee"}
+            {"Portfolio Turnover", "19.96%"},
+            {"OrderListHash", "0f357e8eeee4108d6b53f2b671e97f29"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateIndexAlgorithm.cs

@@ -34,7 +34,7 @@ namespace QuantConnect.Algorithm.CSharp
         protected Symbol SpxOption;
         private ExponentialMovingAverage _emaSlow;
         private ExponentialMovingAverage _emaFast;
-        
+
         protected virtual Resolution Resolution => Resolution.Minute;
         protected virtual int StartDay => 4;
 
@@ -112,7 +112,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public virtual long DataPoints => 16690;
+        public virtual long DataPoints => 16049;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -124,48 +124,31 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public virtual Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
-            {"Total Trades", "4"},
-            {"Average Win", "0%"},
-            {"Average Loss", "-53.10%"},
-            {"Compounding Annual Return", "-92.544%"},
-            {"Drawdown", "10.100%"},
-            {"Expectancy", "-1"},
-            {"Net Profit", "-9.915%"},
-            {"Sharpe Ratio", "-3.845"},
-            {"Probabilistic Sharpe Ratio", "0.053%"},
-            {"Loss Rate", "100%"},
-            {"Win Rate", "0%"},
+            {"Total Trades", "3"},
+            {"Average Win", "6.15%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "435.569%"},
+            {"Drawdown", "3.400%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "5.516%"},
+            {"Sharpe Ratio", "-6.336"},
+            {"Sortino Ratio", "-12.182"},
+            {"Probabilistic Sharpe Ratio", "0.011%"},
+            {"Loss Rate", "0%"},
+            {"Win Rate", "100%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "-0.558"},
-            {"Beta", "0.313"},
-            {"Annual Standard Deviation", "0.112"},
-            {"Annual Variance", "0.013"},
-            {"Information Ratio", "-6.652"},
-            {"Tracking Error", "0.125"},
-            {"Treynor Ratio", "-1.379"},
+            {"Alpha", "-0.226"},
+            {"Beta", "0.02"},
+            {"Annual Standard Deviation", "0.034"},
+            {"Annual Variance", "0.001"},
+            {"Information Ratio", "-7.032"},
+            {"Tracking Error", "0.107"},
+            {"Treynor Ratio", "-10.906"},
             {"Total Fees", "$0.00"},
-            {"Estimated Strategy Capacity", "$13000000.00"},
+            {"Estimated Strategy Capacity", "$3000.00"},
             {"Lowest Capacity Asset", "SPX XL80P3GHDZXQ|SPX 31"},
-            {"Fitness Score", "0.039"},
-            {"Kelly Criterion Estimate", "0"},
-            {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "-1.763"},
-            {"Return Over Maximum Drawdown", "-9.371"},
-            {"Portfolio Turnover", "0.278"},
-            {"Total Insights Generated", "0"},
-            {"Total Insights Closed", "0"},
-            {"Total Insights Analysis Completed", "0"},
-            {"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", "0668385036aba3e95127607dfc2f1a59"}
+            {"Portfolio Turnover", "24.07%"},
+            {"OrderListHash", "d1987f604e6d61584838ccc94adf7256"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateIndexDailyAlgorithm.cs

@@ -1,6 +1,22 @@
+/*
+ * 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 System.Collections.Generic;
 
 namespace QuantConnect.Algorithm.CSharp
 {
@@ -12,10 +28,10 @@ namespace QuantConnect.Algorithm.CSharp
         protected override Resolution Resolution => Resolution.Daily;
         protected override int StartDay => 1;
 
-        // two complete weeks starting from the 5th plus the 18th bar
-        protected virtual int ExpectedBarCount => 2 * 5 + 1;
+        // two complete weeks starting from the 5th. The 18th bar is not included since it is a holiday
+        protected virtual int ExpectedBarCount => 2 * 5;
         protected int BarCounter = 0;
-        
+
         /// <summary>
         /// Purchase a contract when we are not invested, liquidate otherwise
         /// </summary>
@@ -30,7 +46,7 @@ namespace QuantConnect.Algorithm.CSharp
             {
                 Liquidate();
             }
-            
+
             // Count how many slices we receive with SPX data in it to assert later
             if (slice.ContainsKey(Spx))
             {
@@ -59,7 +75,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public override long DataPoints => 122;
+        public override long DataPoints => 0;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -71,48 +87,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public override Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
-            {"Total Trades", "9"},
-            {"Average Win", "0%"},
-            {"Average Loss", "-39.42%"},
-            {"Compounding Annual Return", "394.321%"},
-            {"Drawdown", "0.200%"},
-            {"Expectancy", "-1"},
-            {"Net Profit", "8.219%"},
-            {"Sharpe Ratio", "6.812"},
-            {"Probabilistic Sharpe Ratio", "91.380%"},
-            {"Loss Rate", "100%"},
-            {"Win Rate", "0%"},
-            {"Profit-Loss Ratio", "0"},
-            {"Alpha", "2.236"},
-            {"Beta", "-1.003"},
-            {"Annual Standard Deviation", "0.317"},
-            {"Annual Variance", "0.101"},
-            {"Information Ratio", "5.805"},
-            {"Tracking Error", "0.359"},
-            {"Treynor Ratio", "-2.153"},
-            {"Total Fees", "$0.00"},
-            {"Estimated Strategy Capacity", "$0"},
-            {"Lowest Capacity Asset", "SPX XL80P3GHDZXQ|SPX 31"},
-            {"Fitness Score", "0.027"},
-            {"Kelly Criterion Estimate", "0"},
-            {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "1776.081"},
-            {"Portfolio Turnover", "0.027"},
-            {"Total Insights Generated", "0"},
-            {"Total Insights Closed", "0"},
-            {"Total Insights Analysis Completed", "0"},
-            {"Long Insight Count", "0"},
-            {"Short Insight Count", "0"},
-            {"Long/Short Ratio", "100%"},
-            {"Estimated Monthly Alpha Value", "$0"},
-            {"Total Accumulated Estimated Alpha Value", "$0"},
-            {"Mean Population Estimated Insight Value", "$0"},
-            {"Mean Population Direction", "0%"},
-            {"Mean Population Magnitude", "0%"},
-            {"Rolling Averaged Population Direction", "0%"},
-            {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "474e8e0e28ee84c869f8c69ec3efe371"}
+            {"OrderListHash", "d41d8cd98f00b204e9800998ecf8427e"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateIndexHourlyAlgorithm.cs

@@ -8,7 +8,7 @@ namespace QuantConnect.Algorithm.CSharp
     public class BasicTemplateIndexHourlyAlgorithm : BasicTemplateIndexDailyAlgorithm
     {
         protected override Resolution Resolution => Resolution.Hour;
-        protected override int ExpectedBarCount => base.ExpectedBarCount * 8;
+        protected override int ExpectedBarCount => base.ExpectedBarCount * 7;
 
         /// <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.
@@ -23,7 +23,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public override long DataPoints => 408;
+        public override long DataPoints => 391;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -35,48 +35,31 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public override Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
-            {"Total Trades", "70"},
-            {"Average Win", "0%"},
-            {"Average Loss", "-0.23%"},
-            {"Compounding Annual Return", "-34.441%"},
-            {"Drawdown", "2.000%"},
-            {"Expectancy", "-1"},
-            {"Net Profit", "-2.028%"},
-            {"Sharpe Ratio", "-11.139"},
-            {"Probabilistic Sharpe Ratio", "0.000%"},
-            {"Loss Rate", "100%"},
-            {"Win Rate", "0%"},
-            {"Profit-Loss Ratio", "0"},
-            {"Alpha", "-0.269"},
-            {"Beta", "0.086"},
-            {"Annual Standard Deviation", "0.023"},
-            {"Annual Variance", "0.001"},
-            {"Information Ratio", "-3.624"},
-            {"Tracking Error", "0.094"},
-            {"Treynor Ratio", "-3.042"},
+            {"Total Trades", "71"},
+            {"Average Win", "1.28%"},
+            {"Average Loss", "-0.06%"},
+            {"Compounding Annual Return", "-20.546%"},
+            {"Drawdown", "1.800%"},
+            {"Expectancy", "-0.402"},
+            {"Net Profit", "-0.922%"},
+            {"Sharpe Ratio", "-2.903"},
+            {"Sortino Ratio", "-6.081"},
+            {"Probabilistic Sharpe Ratio", "22.230%"},
+            {"Loss Rate", "97%"},
+            {"Win Rate", "3%"},
+            {"Profit-Loss Ratio", "19.95"},
+            {"Alpha", "-0.157"},
+            {"Beta", "0.025"},
+            {"Annual Standard Deviation", "0.053"},
+            {"Annual Variance", "0.003"},
+            {"Information Ratio", "-2.07"},
+            {"Tracking Error", "0.121"},
+            {"Treynor Ratio", "-6.189"},
             {"Total Fees", "$0.00"},
-            {"Estimated Strategy Capacity", "$310000.00"},
+            {"Estimated Strategy Capacity", "$300000.00"},
             {"Lowest Capacity Asset", "SPX XL80P3GHDZXQ|SPX 31"},
-            {"Fitness Score", "0.002"},
-            {"Kelly Criterion Estimate", "0"},
-            {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "-14.51"},
-            {"Return Over Maximum Drawdown", "-17.213"},
-            {"Portfolio Turnover", "0.299"},
-            {"Total Insights Generated", "0"},
-            {"Total Insights Closed", "0"},
-            {"Total Insights Analysis Completed", "0"},
-            {"Long Insight Count", "0"},
-            {"Short Insight Count", "0"},
-            {"Long/Short Ratio", "100%"},
-            {"Estimated Monthly Alpha Value", "$0"},
-            {"Total Accumulated Estimated Alpha Value", "$0"},
-            {"Mean Population Estimated Insight Value", "$0"},
-            {"Mean Population Direction", "0%"},
-            {"Mean Population Magnitude", "0%"},
-            {"Rolling Averaged Population Direction", "0%"},
-            {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "3eb56c551f20e2ffa1c56c47c5ee6667"}
+            {"Portfolio Turnover", "24.63%"},
+            {"OrderListHash", "380076bc7854977f46318e8add9f1a25"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateIndexOptionsDailyAlgorithm.cs

@@ -14,10 +14,9 @@
  *
 */
 
-using System;
-using System.Collections.Generic;
 using System.Linq;
 using QuantConnect.Data;
+using System.Collections.Generic;
 
 namespace QuantConnect.Algorithm.CSharp
 {
@@ -68,7 +67,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public override long DataPoints => 381;
+        public override long DataPoints => 0;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -80,48 +79,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public override Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
-            {"Total Trades", "9"},
-            {"Average Win", "0%"},
-            {"Average Loss", "-0.01%"},
-            {"Compounding Annual Return", "-0.091%"},
-            {"Drawdown", "0.000%"},
-            {"Expectancy", "-1"},
-            {"Net Profit", "-0.008%"},
-            {"Sharpe Ratio", "-4.033"},
-            {"Probabilistic Sharpe Ratio", "0.013%"},
-            {"Loss Rate", "100%"},
-            {"Win Rate", "0%"},
-            {"Profit-Loss Ratio", "0"},
-            {"Alpha", "-0.001"},
-            {"Beta", "0"},
-            {"Annual Standard Deviation", "0"},
-            {"Annual Variance", "0"},
-            {"Information Ratio", "-0.447"},
-            {"Tracking Error", "0.136"},
-            {"Treynor Ratio", "-4.612"},
-            {"Total Fees", "$0.00"},
-            {"Estimated Strategy Capacity", "$0"},
-            {"Lowest Capacity Asset", "SPX XL80P59H5E6M|SPX 31"},
-            {"Fitness Score", "0"},
-            {"Kelly Criterion Estimate", "0"},
-            {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "-50718.291"},
-            {"Return Over Maximum Drawdown", "-11.386"},
-            {"Portfolio Turnover", "0"},
-            {"Total Insights Generated", "0"},
-            {"Total Insights Closed", "0"},
-            {"Total Insights Analysis Completed", "0"},
-            {"Long Insight Count", "0"},
-            {"Short Insight Count", "0"},
-            {"Long/Short Ratio", "100%"},
-            {"Estimated Monthly Alpha Value", "$0"},
-            {"Total Accumulated Estimated Alpha Value", "$0"},
-            {"Mean Population Estimated Insight Value", "$0"},
-            {"Mean Population Direction", "0%"},
-            {"Mean Population Magnitude", "0%"},
-            {"Rolling Averaged Population Direction", "0%"},
-            {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "5f5df233d68d9115a0d81785de54e71d"}
+            {"OrderListHash", "d41d8cd98f00b204e9800998ecf8427e"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateIndexOptionsHourlyAlgorithm.cs

@@ -38,7 +38,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public override long DataPoints => 2212;
+        public override long DataPoints => 2143;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -50,48 +50,31 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public override Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
-            {"Total Trades", "70"},
+            {"Total Trades", "72"},
             {"Average Win", "0.00%"},
             {"Average Loss", "0.00%"},
-            {"Compounding Annual Return", "0%"},
+            {"Compounding Annual Return", "-0.006%"},
             {"Drawdown", "0.000%"},
-            {"Expectancy", "0.000"},
-            {"Net Profit", "0%"},
-            {"Sharpe Ratio", "0"},
-            {"Probabilistic Sharpe Ratio", "36.504%"},
+            {"Expectancy", "-0.486"},
+            {"Net Profit", "0.000%"},
+            {"Sharpe Ratio", "-101.77"},
+            {"Sortino Ratio", "-9053542.758"},
+            {"Probabilistic Sharpe Ratio", "17.439%"},
             {"Loss Rate", "97%"},
             {"Win Rate", "3%"},
-            {"Profit-Loss Ratio", "34.00"},
-            {"Alpha", "0"},
+            {"Profit-Loss Ratio", "17.50"},
+            {"Alpha", "-0.003"},
             {"Beta", "-0"},
             {"Annual Standard Deviation", "0"},
             {"Annual Variance", "0"},
             {"Information Ratio", "-0.449"},
             {"Tracking Error", "0.138"},
-            {"Treynor Ratio", "-0"},
+            {"Treynor Ratio", "116.921"},
             {"Total Fees", "$0.00"},
             {"Estimated Strategy Capacity", "$0"},
             {"Lowest Capacity Asset", "SPX XL80P59H5E6M|SPX 31"},
-            {"Fitness Score", "0"},
-            {"Kelly Criterion Estimate", "0"},
-            {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "0"},
-            {"Portfolio Turnover", "0"},
-            {"Total Insights Generated", "0"},
-            {"Total Insights Closed", "0"},
-            {"Total Insights Analysis Completed", "0"},
-            {"Long Insight Count", "0"},
-            {"Short Insight Count", "0"},
-            {"Long/Short Ratio", "100%"},
-            {"Estimated Monthly Alpha Value", "$0"},
-            {"Total Accumulated Estimated Alpha Value", "$0"},
-            {"Mean Population Estimated Insight Value", "$0"},
-            {"Mean Population Direction", "0%"},
-            {"Mean Population Magnitude", "0%"},
-            {"Rolling Averaged Population Direction", "0%"},
-            {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "f21910eb98ceaa39e02020de95354d86"}
+            {"Portfolio Turnover", "0.00%"},
+            {"OrderListHash", "832944f7bfd8801bb37e5683a7510705"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateIndiaAlgorithm.cs

@@ -104,7 +104,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "0.000%"},
             {"Expectancy", "0"},
             {"Net Profit", "-0.008%"},
-            {"Sharpe Ratio", "-1.183"},
+            {"Sharpe Ratio", "-497.389"},
+            {"Sortino Ratio", "-73.22"},
             {"Probabilistic Sharpe Ratio", "0.001%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
@@ -119,26 +120,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Fees", "₹6.00"},
             {"Estimated Strategy Capacity", "₹61000000000.00"},
             {"Lowest Capacity Asset", "YESBANK UL"},
-            {"Fitness Score", "0"},
-            {"Kelly Criterion Estimate", "0"},
-            {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "-0.247"},
-            {"Return Over Maximum Drawdown", "-1.104"},
-            {"Portfolio Turnover", "0"},
-            {"Total Insights Generated", "0"},
-            {"Total Insights Closed", "0"},
-            {"Total Insights Analysis Completed", "0"},
-            {"Long Insight Count", "0"},
-            {"Short Insight Count", "0"},
-            {"Long/Short Ratio", "100%"},
-            {"Estimated Monthly Alpha Value", "₹0"},
-            {"Total Accumulated Estimated Alpha Value", "₹0"},
-            {"Mean Population Estimated Insight Value", "₹0"},
-            {"Mean Population Direction", "0%"},
-            {"Mean Population Magnitude", "0%"},
-            {"Rolling Averaged Population Direction", "0%"},
-            {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "6cc69218edd7bd461678b9ee0c575db5"}
+            {"Portfolio Turnover", "0.00%"},
+            {"OrderListHash", "0cfbdeedf1ba2a02af1b6b35dfe8aac3"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateIndiaIndexAlgorithm.cs

@@ -124,11 +124,12 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "6"},
             {"Average Win", "0%"},
             {"Average Loss", "0.00%"},
-            {"Compounding Annual Return", "-0.395%"},
+            {"Compounding Annual Return", "-0.386%"},
             {"Drawdown", "0.000%"},
             {"Expectancy", "-1"},
             {"Net Profit", "-0.004%"},
-            {"Sharpe Ratio", "-23.595"},
+            {"Sharpe Ratio", "-328.371"},
+            {"Sortino Ratio", "-328.371"},
             {"Probabilistic Sharpe Ratio", "0%"},
             {"Loss Rate", "100%"},
             {"Win Rate", "0%"},
@@ -141,28 +142,10 @@ namespace QuantConnect.Algorithm.CSharp
             {"Tracking Error", "0"},
             {"Treynor Ratio", "0"},
             {"Total Fees", "₹36.00"},
-            {"Estimated Strategy Capacity", "₹74000.00"},
+            {"Estimated Strategy Capacity", "₹84000.00"},
             {"Lowest Capacity Asset", "JUNIORBEES UL"},
-            {"Fitness Score", "0"},
-            {"Kelly Criterion Estimate", "0"},
-            {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "-29.6"},
-            {"Return Over Maximum Drawdown", "-123.624"},
-            {"Portfolio Turnover", "0"},
-            {"Total Insights Generated", "0"},
-            {"Total Insights Closed", "0"},
-            {"Total Insights Analysis Completed", "0"},
-            {"Long Insight Count", "0"},
-            {"Short Insight Count", "0"},
-            {"Long/Short Ratio", "100%"},
-            {"Estimated Monthly Alpha Value", "₹0"},
-            {"Total Accumulated Estimated Alpha Value", "₹0"},
-            {"Mean Population Estimated Insight Value", "₹0"},
-            {"Mean Population Direction", "0%"},
-            {"Mean Population Magnitude", "0%"},
-            {"Rolling Averaged Population Direction", "0%"},
-            {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "4637f26543287548b28a3c296db055d3"}
+            {"Portfolio Turnover", "0.04%"},
+            {"OrderListHash", "5823d79e97915654a8f68ae5fa600b5a"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateOptionEquityStrategyAlgorithm.cs

@@ -102,7 +102,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 884208;
+        public long DataPoints => 471135;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -122,6 +122,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Expectancy", "0"},
             {"Net Profit", "0%"},
             {"Sharpe Ratio", "0"},
+            {"Sortino Ratio", "0"},
             {"Probabilistic Sharpe Ratio", "0%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
@@ -133,29 +134,11 @@ namespace QuantConnect.Algorithm.CSharp
             {"Information Ratio", "0"},
             {"Tracking Error", "0"},
             {"Treynor Ratio", "0"},
-            {"Total Fees", "$10.00"},
-            {"Estimated Strategy Capacity", "$84000.00"},
+            {"Total Fees", "$26.00"},
+            {"Estimated Strategy Capacity", "$70000.00"},
             {"Lowest Capacity Asset", "GOOCV W78ZERHAOVVQ|GOOCV VP83T1ZUHROL"},
-            {"Fitness Score", "0"},
-            {"Kelly Criterion Estimate", "0"},
-            {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "0"},
-            {"Return Over Maximum Drawdown", "0"},
-            {"Portfolio Turnover", "0"},
-            {"Total Insights Generated", "0"},
-            {"Total Insights Closed", "0"},
-            {"Total Insights Analysis Completed", "0"},
-            {"Long Insight Count", "0"},
-            {"Short Insight Count", "0"},
-            {"Long/Short Ratio", "100%"},
-            {"Estimated Monthly Alpha Value", "$0"},
-            {"Total Accumulated Estimated Alpha Value", "$0"},
-            {"Mean Population Estimated Insight Value", "$0"},
-            {"Mean Population Direction", "0%"},
-            {"Mean Population Magnitude", "0%"},
-            {"Rolling Averaged Population Direction", "0%"},
-            {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "0673d23c27fa8dd01da0aace0e866cc3"}
+            {"Portfolio Turnover", "61.31%"},
+            {"OrderListHash", "a36c60c5fb020121d6541683138d8f28"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateOptionStrategyAlgorithm.cs

@@ -112,7 +112,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 884616;
+        public long DataPoints => 471124;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -124,7 +124,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
-            {"Total Trades", "778"},
+            {"Total Trades", "418"},
             {"Average Win", "0%"},
             {"Average Loss", "0%"},
             {"Compounding Annual Return", "0%"},
@@ -132,6 +132,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Expectancy", "0"},
             {"Net Profit", "0%"},
             {"Sharpe Ratio", "0"},
+            {"Sortino Ratio", "0"},
             {"Probabilistic Sharpe Ratio", "0%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
@@ -143,29 +144,11 @@ namespace QuantConnect.Algorithm.CSharp
             {"Information Ratio", "0"},
             {"Tracking Error", "0"},
             {"Treynor Ratio", "0"},
-            {"Total Fees", "$778.00"},
-            {"Estimated Strategy Capacity", "$1000.00"},
+            {"Total Fees", "$543.40"},
+            {"Estimated Strategy Capacity", "$3000.00"},
             {"Lowest Capacity Asset", "GOOCV W78ZFMEBBB2E|GOOCV VP83T1ZUHROL"},
-            {"Fitness Score", "0"},
-            {"Kelly Criterion Estimate", "0"},
-            {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "0"},
-            {"Return Over Maximum Drawdown", "0"},
-            {"Portfolio Turnover", "0"},
-            {"Total Insights Generated", "0"},
-            {"Total Insights Closed", "0"},
-            {"Total Insights Analysis Completed", "0"},
-            {"Long Insight Count", "0"},
-            {"Short Insight Count", "0"},
-            {"Long/Short Ratio", "100%"},
-            {"Estimated Monthly Alpha Value", "$0"},
-            {"Total Accumulated Estimated Alpha Value", "$0"},
-            {"Mean Population Estimated Insight Value", "$0"},
-            {"Mean Population Direction", "0%"},
-            {"Mean Population Magnitude", "0%"},
-            {"Rolling Averaged Population Direction", "0%"},
-            {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "6a88f302b7f29a2c59e4b1e978161da1"}
+            {"Portfolio Turnover", "338.60%"},
+            {"OrderListHash", "c9eb598f33939941206efc018eb6ee45"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateOptionsAlgorithm.cs

@@ -109,7 +109,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 884197;
+        public long DataPoints => 471124;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -129,6 +129,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Expectancy", "0"},
             {"Net Profit", "0%"},
             {"Sharpe Ratio", "0"},
+            {"Sortino Ratio", "0"},
             {"Probabilistic Sharpe Ratio", "0%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
@@ -143,26 +144,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Fees", "$2.00"},
             {"Estimated Strategy Capacity", "$1300000.00"},
             {"Lowest Capacity Asset", "GOOCV 30AKMEIPOSS1Y|GOOCV VP83T1ZUHROL"},
-            {"Fitness Score", "0"},
-            {"Kelly Criterion Estimate", "0"},
-            {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "0"},
-            {"Return Over Maximum Drawdown", "0"},
-            {"Portfolio Turnover", "0"},
-            {"Total Insights Generated", "0"},
-            {"Total Insights Closed", "0"},
-            {"Total Insights Analysis Completed", "0"},
-            {"Long Insight Count", "0"},
-            {"Short Insight Count", "0"},
-            {"Long/Short Ratio", "100%"},
-            {"Estimated Monthly Alpha Value", "$0"},
-            {"Total Accumulated Estimated Alpha Value", "$0"},
-            {"Mean Population Estimated Insight Value", "$0"},
-            {"Mean Population Direction", "0%"},
-            {"Mean Population Magnitude", "0%"},
-            {"Rolling Averaged Population Direction", "0%"},
-            {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "9d9f9248ee8fe30d87ff0a6f6fea5112"}
+            {"Portfolio Turnover", "10.71%"},
+            {"OrderListHash", "6b2f02d5cedb870e539a7bfb967c777f"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateOptionsConsolidationAlgorithm.cs

@@ -0,0 +1,144 @@
+/*
+ * 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.Consolidators;
+using QuantConnect.Data.Market;
+using QuantConnect.Data.UniverseSelection;
+using QuantConnect.Interfaces;
+using System;
+using System.Collections.Generic;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// A demonstration of consolidating options data into larger bars for your algorithm.
+    /// </summary>
+    public class BasicTemplateOptionsConsolidationAlgorithm: QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Dictionary<Symbol, IDataConsolidator> _consolidators = new();
+
+        public override void Initialize()
+        {
+            SetStartDate(2013, 10, 7);
+            SetEndDate(2013, 10, 11);
+            SetCash(1000000);
+
+            var option = AddOption("SPY");
+            option.SetFilter(-2, 2, 0, 189);
+        }
+
+        public void OnQuoteBarConsolidated(object sender, QuoteBar quoteBar)
+        {
+            Log($"OnQuoteBarConsolidated called on {Time}");
+            Log(quoteBar.ToString());
+        }
+
+        public void OnTradeBarConsolidated(object sender, TradeBar tradeBar)
+        {
+            Log($"OnTradeBarConsolidated called on {Time}");
+            Log(tradeBar.ToString());
+        }
+
+        public override void OnSecuritiesChanged(SecurityChanges changes)
+        {
+            foreach(var security in changes.AddedSecurities)
+            {
+                IDataConsolidator consolidator;
+                if (security.Type == SecurityType.Equity)
+                {
+                    consolidator = new TradeBarConsolidator(TimeSpan.FromMinutes(5));
+                    (consolidator as TradeBarConsolidator).DataConsolidated += OnTradeBarConsolidated;
+                }
+                else
+                {
+                    consolidator = new QuoteBarConsolidator(new TimeSpan(0, 5, 0));
+                    (consolidator as QuoteBarConsolidator).DataConsolidated += OnQuoteBarConsolidated;
+                }
+
+                SubscriptionManager.AddConsolidator(security.Symbol, consolidator);
+                _consolidators[security.Symbol] = consolidator;
+            }
+
+            foreach(var security in changes.RemovedSecurities)
+            {
+                _consolidators.Remove(security.Symbol, out var consolidator);
+                SubscriptionManager.RemoveConsolidator(security.Symbol, consolidator);
+
+                if (security.Type == SecurityType.Equity)
+                {
+                    (consolidator as TradeBarConsolidator).DataConsolidated -= OnTradeBarConsolidated;
+                }
+                else
+                {
+                    (consolidator as QuoteBarConsolidator).DataConsolidated -= OnQuoteBarConsolidated;
+                }
+            }
+        }
+
+        /// <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>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 3943;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public int AlgorithmHistoryDataPoints => 0;
+
+        /// <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"},
+            {"Sortino 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", "-8.91"},
+            {"Tracking Error", "0.223"},
+            {"Treynor Ratio", "0"},
+            {"Total Fees", "$0.00"},
+            {"Estimated Strategy Capacity", "$0"},
+            {"Lowest Capacity Asset", ""},
+            {"Portfolio Turnover", "0%"},
+            {"OrderListHash", "d41d8cd98f00b204e9800998ecf8427e"}
+        };
+    }
+}

Algorithm.CSharp/BasicTemplateOptionsDailyAlgorithm.cs

@@ -69,7 +69,7 @@ namespace QuantConnect.Algorithm.CSharp
                     var contractsByExpiration = chain.Where(x => x.Expiry != Time.Date).OrderBy(x => x.Expiry);
                     var contract = contractsByExpiration.FirstOrDefault();
 
-                    if (contract != null && IsMarketOpen(contract.Symbol))
+                    if (contract != null)
                     {
                         // if found, trade it
                         MarketOrder(contract.Symbol, 1);
@@ -88,7 +88,7 @@ namespace QuantConnect.Algorithm.CSharp
             Log(orderEvent.ToString());
 
             // Check for our expected OTM option expiry
-            if (orderEvent.Message == "OTM")
+            if (orderEvent.Message.Contains("OTM", StringComparison.InvariantCulture))
             {
                 // Assert it is at midnight (5AM UTC)
                 if (orderEvent.UtcTime != new DateTime(2016, 1, 16, 5, 0, 0))
@@ -122,7 +122,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 39654;
+        public long DataPoints => 36834;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -141,7 +141,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "1.300%"},
             {"Expectancy", "-1"},
             {"Net Profit", "-1.311%"},
-            {"Sharpe Ratio", "-3.31"},
+            {"Sharpe Ratio", "-3.607"},
+            {"Sortino Ratio", "-1.188"},
             {"Probabilistic Sharpe Ratio", "0.035%"},
             {"Loss Rate", "100%"},
             {"Win Rate", "0%"},
@@ -154,28 +155,10 @@ namespace QuantConnect.Algorithm.CSharp
             {"Tracking Error", "0.034"},
             {"Treynor Ratio", "0"},
             {"Total Fees", "$1.00"},
-            {"Estimated Strategy Capacity", "$18000.00"},
+            {"Estimated Strategy Capacity", "$0"},
             {"Lowest Capacity Asset", "GOOCV W78ZFMML01JA|GOOCV VP83T1ZUHROL"},
-            {"Fitness Score", "0"},
-            {"Kelly Criterion Estimate", "0"},
-            {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "-1.496"},
-            {"Return Over Maximum Drawdown", "-11.673"},
-            {"Portfolio Turnover", "0"},
-            {"Total Insights Generated", "0"},
-            {"Total Insights Closed", "0"},
-            {"Total Insights Analysis Completed", "0"},
-            {"Long Insight Count", "0"},
-            {"Short Insight Count", "0"},
-            {"Long/Short Ratio", "100%"},
-            {"Estimated Monthly Alpha Value", "$0"},
-            {"Total Accumulated Estimated Alpha Value", "$0"},
-            {"Mean Population Estimated Insight Value", "$0"},
-            {"Mean Population Direction", "0%"},
-            {"Mean Population Magnitude", "0%"},
-            {"Rolling Averaged Population Direction", "0%"},
-            {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "c6d089f1fb86379c74a7413a9c2f8553"}
+            {"Portfolio Turnover", "0.05%"},
+            {"OrderListHash", "27226eb0860aa34fd513a8a66a732ad0"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateOptionsFilterUniverseAlgorithm.cs

@@ -100,7 +100,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 1722373;
+        public long DataPoints => 1252633;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -120,6 +120,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Expectancy", "-1"},
             {"Net Profit", "-0.311%"},
             {"Sharpe Ratio", "0"},
+            {"Sortino Ratio", "0"},
             {"Probabilistic Sharpe Ratio", "0%"},
             {"Loss Rate", "100%"},
             {"Win Rate", "0%"},
@@ -134,26 +135,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Fees", "$1.00"},
             {"Estimated Strategy Capacity", "$0"},
             {"Lowest Capacity Asset", "GOOCV VP83T1ZUHROL"},
-            {"Fitness Score", "0.188"},
-            {"Kelly Criterion Estimate", "0"},
-            {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "-73.268"},
-            {"Portfolio Turnover", "0.376"},
-            {"Total Insights Generated", "0"},
-            {"Total Insights Closed", "0"},
-            {"Total Insights Analysis Completed", "0"},
-            {"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", "452e7a36e0a95e33d3457a908add3ead"}
+            {"Portfolio Turnover", "15.08%"},
+            {"OrderListHash", "f76ee0af976faeb84643e8fcd6c7b331"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateOptionsFrameworkAlgorithm.cs

@@ -139,7 +139,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 990979;
+        public long DataPoints => 993927;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -156,14 +156,15 @@ namespace QuantConnect.Algorithm.CSharp
             {"Average Loss", "-0.28%"},
             {"Compounding Annual Return", "0%"},
             {"Drawdown", "385.400%"},
-            {"Expectancy", "-0.249"},
+            {"Expectancy", "0.502"},
             {"Net Profit", "-386.489%"},
             {"Sharpe Ratio", "-0.033"},
+            {"Sortino Ratio", "0"},
             {"Probabilistic Sharpe Ratio", "1.235%"},
-            {"Loss Rate", "50%"},
-            {"Win Rate", "50%"},
+            {"Loss Rate", "0%"},
+            {"Win Rate", "100%"},
             {"Profit-Loss Ratio", "0.50"},
-            {"Alpha", "-95.983"},
+            {"Alpha", "-94.012"},
             {"Beta", "263.726"},
             {"Annual Standard Deviation", "30.617"},
             {"Annual Variance", "937.371"},
@@ -173,26 +174,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Fees", "$3.00"},
             {"Estimated Strategy Capacity", "$0"},
             {"Lowest Capacity Asset", "AAPL R735QTJ8XC9X"},
-            {"Fitness Score", "0.168"},
-            {"Kelly Criterion Estimate", "0.327"},
-            {"Kelly Criterion Probability Value", "1"},
-            {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "0"},
-            {"Portfolio Turnover", "0.224"},
-            {"Total Insights Generated", "28"},
-            {"Total Insights Closed", "24"},
-            {"Total Insights Analysis Completed", "24"},
-            {"Long Insight Count", "28"},
-            {"Short Insight Count", "0"},
-            {"Long/Short Ratio", "100%"},
-            {"Estimated Monthly Alpha Value", "$13.64796"},
-            {"Total Accumulated Estimated Alpha Value", "$1.89555"},
-            {"Mean Population Estimated Insight Value", "$0.07898125"},
-            {"Mean Population Direction", "50%"},
-            {"Mean Population Magnitude", "0%"},
-            {"Rolling Averaged Population Direction", "50.0482%"},
-            {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "87603bd45898dd9c456745fa51f989a5"}
+            {"Portfolio Turnover", "13.46%"},
+            {"OrderListHash", "135d5cf7bc14eb9eb88260bbf6b3a671"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateOptionsHourlyAlgorithm.cs

@@ -109,7 +109,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 32492;
+        public long DataPoints => 32351;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -128,41 +128,24 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "0.200%"},
             {"Expectancy", "-1"},
             {"Net Profit", "-0.134%"},
-            {"Sharpe Ratio", "-8.839"},
+            {"Sharpe Ratio", "-9.78"},
+            {"Sortino Ratio", "0"},
             {"Probabilistic Sharpe Ratio", "0%"},
             {"Loss Rate", "100%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "0.083"},
+            {"Alpha", "0.075"},
             {"Beta", "-0.054"},
             {"Annual Standard Deviation", "0.008"},
             {"Annual Variance", "0"},
             {"Information Ratio", "-18.699"},
             {"Tracking Error", "0.155"},
-            {"Treynor Ratio", "1.296"},
+            {"Treynor Ratio", "1.434"},
             {"Total Fees", "$4.00"},
             {"Estimated Strategy Capacity", "$1000.00"},
             {"Lowest Capacity Asset", "AAPL 2ZTXYMUAHCIAU|AAPL R735QTJ8XC9X"},
-            {"Fitness Score", "0.04"},
-            {"Kelly Criterion Estimate", "0"},
-            {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "-118.28"},
-            {"Portfolio Turnover", "0.081"},
-            {"Total Insights Generated", "0"},
-            {"Total Insights Closed", "0"},
-            {"Total Insights Analysis Completed", "0"},
-            {"Long Insight Count", "0"},
-            {"Short Insight Count", "0"},
-            {"Long/Short Ratio", "100%"},
-            {"Estimated Monthly Alpha Value", "$0"},
-            {"Total Accumulated Estimated Alpha Value", "$0"},
-            {"Mean Population Estimated Insight Value", "$0"},
-            {"Mean Population Direction", "0%"},
-            {"Mean Population Magnitude", "0%"},
-            {"Rolling Averaged Population Direction", "0%"},
-            {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "81e8a822d43de2165c1d3f52964ec312"}
+            {"Portfolio Turnover", "2.28%"},
+            {"OrderListHash", "3f6cce0fcc7b988ba378a357ede1af93"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateSPXWeeklyIndexOptionsAlgorithm.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.Linq;
+using QuantConnect.Data;
+using QuantConnect.Orders;
+using QuantConnect.Interfaces;
+using QuantConnect.Data.Market;
+using System.Collections.Generic;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// This example demonstrates how to add and trade SPX index weekly options
+    /// </summary>
+    /// <meta name="tag" content="using data" />
+    /// <meta name="tag" content="options" />
+    /// <meta name="tag" content="indexes" />
+    public class BasicTemplateSPXWeeklyIndexOptionsAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Symbol _spxOption;
+
+        /// <summary>
+        /// Initialize your algorithm and add desired assets.
+        /// </summary>
+        public override void Initialize()
+        {
+            SetStartDate(2021, 1, 4);
+            SetEndDate(2021, 1, 10);
+            SetCash(1000000);
+
+            var spx = AddIndex("SPX").Symbol;
+
+            // regular option SPX contracts
+            var spxOptions = AddIndexOption(spx);
+            spxOptions.SetFilter(u => u.Strikes(0, 1).Expiration(0, 30));
+
+            // weekly option SPX contracts
+            var spxw = AddIndexOption(spx, "SPXW");
+            spxw.SetFilter(u => u.Strikes(0, 1)
+                 // single week ahead since there are many SPXW contracts and we want to preserve performance
+                 .Expiration(0, 7)
+                 .IncludeWeeklys());
+
+            _spxOption = spxw.Symbol;
+        }
+
+        /// <summary>
+        /// Index EMA Cross trading underlying.
+        /// </summary>
+        public override void OnData(Slice slice)
+        {
+            if (Portfolio.Invested)
+            {
+                return;
+            }
+
+            OptionChain chain;
+            if (slice.OptionChains.TryGetValue(_spxOption, out chain))
+            {
+                // we find at the money (ATM) put contract with closest expiration
+                var atmContract = chain
+                    .OrderBy(x => x.Expiry)
+                    .ThenBy(x => Math.Abs(chain.Underlying.Price - x.Strike))
+                    .ThenByDescending(x => x.Right)
+                    .FirstOrDefault();
+
+                if (atmContract != null)
+                {
+                    // if found, buy until it expires
+                    MarketOrder(atmContract.Symbol, 1);
+                }
+            }
+        }
+
+        public override void OnOrderEvent(OrderEvent orderEvent)
+        {
+            Debug(orderEvent.ToString());
+        }
+
+        /// <summary>
+        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
+        /// </summary>
+        public virtual bool CanRunLocally { get; } = true;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public virtual Language[] Languages { get; } = { Language.CSharp, Language.Python };
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public virtual long DataPoints => 57794;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public virtual int AlgorithmHistoryDataPoints => 0;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public virtual Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        {
+            {"Total Trades", "5"},
+            {"Average Win", "0%"},
+            {"Average Loss", "-0.69%"},
+            {"Compounding Annual Return", "58.005%"},
+            {"Drawdown", "0.400%"},
+            {"Expectancy", "-0.5"},
+            {"Net Profit", "0.588%"},
+            {"Sharpe Ratio", "0.836"},
+            {"Sortino Ratio", "0"},
+            {"Probabilistic Sharpe Ratio", "51.980%"},
+            {"Loss Rate", "50%"},
+            {"Win Rate", "50%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "0.286"},
+            {"Beta", "-0.04"},
+            {"Annual Standard Deviation", "0.004"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "-98.963"},
+            {"Tracking Error", "0.072"},
+            {"Treynor Ratio", "-0.086"},
+            {"Total Fees", "$0.00"},
+            {"Estimated Strategy Capacity", "$580000.00"},
+            {"Lowest Capacity Asset", "SPXW 31K54PVWHUJHQ|SPX 31"},
+            {"Portfolio Turnover", "0.48%"},
+            {"OrderListHash", "07469a94a93198bbccadc8bc9cdfe87a"}
+        };
+    }
+}

Algorithm.CSharp/BasicTemplateSPXWeeklyIndexOptionsStrategyAlgorithm.cs

@@ -0,0 +1,151 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+
+using System.Linq;
+using QuantConnect.Data;
+using QuantConnect.Orders;
+using QuantConnect.Interfaces;
+using QuantConnect.Data.Market;
+using System.Collections.Generic;
+using QuantConnect.Securities.Option;
+using System;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// This example demonstrates how to add and trade SPX index weekly option strategy
+    /// </summary>
+    /// <meta name="tag" content="using data" />
+    /// <meta name="tag" content="options" />
+    /// <meta name="tag" content="indexes" />
+    public class BasicTemplateSPXWeeklyIndexOptionsStrategyAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Symbol _spxOption;
+
+        /// <summary>
+        /// Initialize your algorithm and add desired assets.
+        /// </summary>
+        public override void Initialize()
+        {
+            SetStartDate(2021, 1, 4);
+            SetEndDate(2021, 1, 10);
+            SetCash(1000000);
+
+            var spx = AddIndex("SPX").Symbol;
+
+            // weekly option SPX contracts
+            var spxw = AddIndexOption(spx, "SPXW");
+            spxw.SetFilter(u => u.Strikes(-1, +1)
+                 // single week ahead since there are many SPXW contracts and we want to preserve performance
+                 .Expiration(0, 7)
+                 .IncludeWeeklys());
+
+            _spxOption = spxw.Symbol;
+        }
+
+        public override void OnData(Slice slice)
+        {
+            if (Portfolio.Invested)
+            {
+                return;
+            }
+
+            OptionChain chain;
+            if (slice.OptionChains.TryGetValue(_spxOption, out chain))
+            {
+                // we find the first expiration group of call options and order them in ascending strike
+                var contracts = chain
+                    .Where(x => x.Right == OptionRight.Call)
+                    .OrderBy(x => x.Expiry)
+                    .GroupBy(x => x.Expiry)
+                    .First()
+                    .OrderBy(x => x.Strike)
+                    .ToList();
+
+                if (contracts.Count > 1)
+                {
+                    var smallerStrike = contracts[0];
+                    var higherStrike = contracts[1];
+
+                    // if found, buy until it expires
+                    var optionStrategy = OptionStrategies.BearCallSpread(_spxOption, smallerStrike.Strike, higherStrike.Strike, smallerStrike.Expiry);
+                    Buy(optionStrategy, 1);
+                }
+            }
+        }
+
+        public override void OnOrderEvent(OrderEvent orderEvent)
+        {
+            Debug(orderEvent.ToString());
+            if (orderEvent.Symbol.ID.Symbol != "SPXW")
+            {
+                throw new Exception("Unexpected order event symbol!");
+            }
+        }
+
+        /// <summary>
+        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
+        /// </summary>
+        public virtual bool CanRunLocally { get; } = true;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public virtual Language[] Languages { get; } = { Language.CSharp };
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public virtual long DataPoints => 40893;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public virtual int AlgorithmHistoryDataPoints => 0;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public virtual Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        {
+            {"Total Trades", "10"},
+            {"Average Win", "0.47%"},
+            {"Average Loss", "-0.01%"},
+            {"Compounding Annual Return", "99.729%"},
+            {"Drawdown", "0.100%"},
+            {"Expectancy", "24.484"},
+            {"Net Profit", "0.890%"},
+            {"Sharpe Ratio", "8.078"},
+            {"Sortino Ratio", "0"},
+            {"Probabilistic Sharpe Ratio", "93.697%"},
+            {"Loss Rate", "50%"},
+            {"Win Rate", "50%"},
+            {"Profit-Loss Ratio", "49.97"},
+            {"Alpha", "-1.975"},
+            {"Beta", "0.301"},
+            {"Annual Standard Deviation", "0.021"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "-143.477"},
+            {"Tracking Error", "0.049"},
+            {"Treynor Ratio", "0.566"},
+            {"Total Fees", "$0.00"},
+            {"Estimated Strategy Capacity", "$13000000.00"},
+            {"Lowest Capacity Asset", "SPXW XKX6S2GM9PGU|SPX 31"},
+            {"Portfolio Turnover", "0.28%"},
+            {"OrderListHash", "69b28e4f5b33ff54f173c14ea1e00c50"}
+        };
+    }
+}

Algorithm.CSharp/BasicTemplateTradableIndexAlgorithm.cs

@@ -0,0 +1,93 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+
+using System;
+using QuantConnect.Data;
+using System.Collections.Generic;
+using QuantConnect.Orders;
+using System.Linq;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// This example demonstrates how to add index asset types and change the tradable condition
+    /// </summary>
+    /// <meta name="tag" content="using data" />
+    /// <meta name="tag" content="benchmarks" />
+    /// <meta name="tag" content="indexes" />
+    public class BasicTemplateTradableIndexAlgorithm : BasicTemplateIndexAlgorithm
+    {
+        private OrderTicket _ticket;
+
+        /// <summary>
+        /// Initialize your algorithm and add desired assets.
+        /// </summary>
+        public override void Initialize()
+        {
+            base.Initialize();
+            Securities[Spx].IsTradable = true;
+        }
+
+        /// <summary>
+        /// Index EMA Cross trading underlying.
+        /// </summary>
+        public override void OnData(Slice slice)
+        {
+            base.OnData(slice);
+            _ticket ??= MarketOrder(Spx, 1);
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            if (!_ticket.Status.IsFill())
+            {
+                throw new Exception("Index is tradable.");
+            }
+        }
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public override Dictionary<string, string> ExpectedStatistics => new()
+        {
+            {"Total Trades", "5"},
+            {"Average Win", "6.15%"},
+            {"Average Loss", "-0.01%"},
+            {"Compounding Annual Return", "434.741%"},
+            {"Drawdown", "3.400%"},
+            {"Expectancy", "589.124"},
+            {"Net Profit", "5.510%"},
+            {"Sharpe Ratio", "-6.336"},
+            {"Sortino Ratio", "-12.182"},
+            {"Probabilistic Sharpe Ratio", "0.011%"},
+            {"Loss Rate", "50%"},
+            {"Win Rate", "50%"},
+            {"Profit-Loss Ratio", "1179.25"},
+            {"Alpha", "-0.226"},
+            {"Beta", "0.02"},
+            {"Annual Standard Deviation", "0.034"},
+            {"Annual Variance", "0.001"},
+            {"Information Ratio", "-7.032"},
+            {"Tracking Error", "0.107"},
+            {"Treynor Ratio", "-10.906"},
+            {"Total Fees", "$0.00"},
+            {"Estimated Strategy Capacity", "$3000.00"},
+            {"Lowest Capacity Asset", "SPX XL80P3GHDZXQ|SPX 31"},
+            {"Portfolio Turnover", "24.13%"},
+            {"OrderListHash", "41644492e032f38d0d9be0915f09a03b"}
+        };
+    }
+}

Algorithm.CSharp/Benchmarks/EmptyEquityAndOptions400Benchmark.cs

@@ -64,7 +64,7 @@ namespace QuantConnect.Algorithm.CSharp.Benchmarks
 "OSCR", "WOLF", "SYF", "GOGL", "HES", "PHM", "CWEB", "ALDX", "BTWN", "AFL", "PPL", "CIM"
 
             };
-            Settings.DataSubscriptionLimit = 1000000;
+            
             SetWarmUp(TimeSpan.FromDays(1));
             foreach(var ticker in equity_symbols)
             {

Algorithm.CSharp/BinanceCashAccountFeeRegressionAlgorithm.cs

@@ -61,6 +61,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Expectancy", "0"},
             {"Net Profit", "0%"},
             {"Sharpe Ratio", "0"},
+            {"Sortino Ratio", "0"},
             {"Probabilistic Sharpe Ratio", "0%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
@@ -75,26 +76,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Fees", "₮45.62"},
             {"Estimated Strategy Capacity", "₮220000.00"},
             {"Lowest Capacity Asset", "BTCUSDT 18N"},
-            {"Fitness Score", "0.208"},
-            {"Kelly Criterion Estimate", "0"},
-            {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "26.189"},
-            {"Portfolio Turnover", "0.208"},
-            {"Total Insights Generated", "0"},
-            {"Total Insights Closed", "0"},
-            {"Total Insights Analysis Completed", "0"},
-            {"Long Insight Count", "0"},
-            {"Short Insight Count", "0"},
-            {"Long/Short Ratio", "100%"},
-            {"Estimated Monthly Alpha Value", "₮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", "7417649395922ff3791471b4f3b5c021"}
+            {"Portfolio Turnover", "22.80%"},
+            {"OrderListHash", "3981b9ec6c7940ae6b0e763212390cc6"}
         };
     }
 }

Algorithm.CSharp/BinanceMarginAccountFeeRegressionAlgorithm.cs

@@ -61,6 +61,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Expectancy", "0"},
             {"Net Profit", "0%"},
             {"Sharpe Ratio", "0"},
+            {"Sortino Ratio", "0"},
             {"Probabilistic Sharpe Ratio", "0%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
@@ -75,26 +76,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Fees", "₮45.62"},
             {"Estimated Strategy Capacity", "₮12000000.00"},
             {"Lowest Capacity Asset", "BTCUSDT 18N"},
-            {"Fitness Score", "0.208"},
-            {"Kelly Criterion Estimate", "0"},
-            {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "26.189"},
-            {"Portfolio Turnover", "0.208"},
-            {"Total Insights Generated", "0"},
-            {"Total Insights Closed", "0"},
-            {"Total Insights Analysis Completed", "0"},
-            {"Long Insight Count", "0"},
-            {"Short Insight Count", "0"},
-            {"Long/Short Ratio", "100%"},
-            {"Estimated Monthly Alpha Value", "₮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", "7417649395922ff3791471b4f3b5c021"}
+            {"Portfolio Turnover", "22.80%"},
+            {"OrderListHash", "3981b9ec6c7940ae6b0e763212390cc6"}
         };
     }
 }

Algorithm.CSharp/BitfinexCashAccountFeeRegressionAlgorithm.cs

@@ -60,6 +60,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Expectancy", "0"},
             {"Net Profit", "0%"},
             {"Sharpe Ratio", "0"},
+            {"Sortino Ratio", "0"},
             {"Probabilistic Sharpe Ratio", "0%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
@@ -74,26 +75,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Fees", "$1.13"},
             {"Estimated Strategy Capacity", "$2000.00"},
             {"Lowest Capacity Asset", "BTCUSD E3"},
-            {"Fitness Score", "0.002"},
-            {"Kelly Criterion Estimate", "0"},
-            {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "79228162514264337593543950335"},
-            {"Portfolio Turnover", "0.002"},
-            {"Total Insights Generated", "0"},
-            {"Total Insights Closed", "0"},
-            {"Total Insights Analysis Completed", "0"},
-            {"Long Insight Count", "0"},
-            {"Short Insight Count", "0"},
-            {"Long/Short Ratio", "100%"},
-            {"Estimated Monthly Alpha Value", "$0"},
-            {"Total Accumulated Estimated Alpha Value", "$0"},
-            {"Mean Population Estimated Insight Value", "$0"},
-            {"Mean Population Direction", "0%"},
-            {"Mean Population Magnitude", "0%"},
-            {"Rolling Averaged Population Direction", "0%"},
-            {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "7f892f0c42d8826ff770ee602fe207a2"}
+            {"Portfolio Turnover", "0.28%"},
+            {"OrderListHash", "3c23bc8622691cb9d4cacb00de5b0dd8"}
         };
     }
 }

Algorithm.CSharp/BitfinexMarginAccountFeeRegressionAlgorithm.cs

@@ -60,6 +60,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Expectancy", "0"},
             {"Net Profit", "0%"},
             {"Sharpe Ratio", "0"},
+            {"Sortino Ratio", "0"},
             {"Probabilistic Sharpe Ratio", "0%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
@@ -74,26 +75,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Fees", "$1.13"},
             {"Estimated Strategy Capacity", "$640000.00"},
             {"Lowest Capacity Asset", "BTCUSD E3"},
-            {"Fitness Score", "0.002"},
-            {"Kelly Criterion Estimate", "0"},
-            {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "79228162514264337593543950335"},
-            {"Portfolio Turnover", "0.002"},
-            {"Total Insights Generated", "0"},
-            {"Total Insights Closed", "0"},
-            {"Total Insights Analysis Completed", "0"},
-            {"Long Insight Count", "0"},
-            {"Short Insight Count", "0"},
-            {"Long/Short Ratio", "100%"},
-            {"Estimated Monthly Alpha Value", "$0"},
-            {"Total Accumulated Estimated Alpha Value", "$0"},
-            {"Mean Population Estimated Insight Value", "$0"},
-            {"Mean Population Direction", "0%"},
-            {"Mean Population Magnitude", "0%"},
-            {"Rolling Averaged Population Direction", "0%"},
-            {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "7f892f0c42d8826ff770ee602fe207a2"}
+            {"Portfolio Turnover", "0.28%"},
+            {"OrderListHash", "3c23bc8622691cb9d4cacb00de5b0dd8"}
         };
     }
 }

Algorithm.CSharp/BlackLittermanPortfolioOptimizationFrameworkAlgorithm.cs

@@ -88,48 +88,31 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
-            {"Total Trades", "20"},
+            {"Total Trades", "14"},
             {"Average Win", "0%"},
-            {"Average Loss", "-0.13%"},
-            {"Compounding Annual Return", "62.435%"},
+            {"Average Loss", "-0.23%"},
+            {"Compounding Annual Return", "63.336%"},
             {"Drawdown", "1.100%"},
             {"Expectancy", "-1"},
-            {"Net Profit", "0.667%"},
-            {"Sharpe Ratio", "3.993"},
-            {"Probabilistic Sharpe Ratio", "58.777%"},
+            {"Net Profit", "0.674%"},
+            {"Sharpe Ratio", "3.986"},
+            {"Sortino Ratio", "0"},
+            {"Probabilistic Sharpe Ratio", "58.892%"},
             {"Loss Rate", "100%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "-0.598"},
-            {"Beta", "0.569"},
+            {"Alpha", "-0.595"},
+            {"Beta", "0.57"},
             {"Annual Standard Deviation", "0.133"},
             {"Annual Variance", "0.018"},
-            {"Information Ratio", "-13.973"},
+            {"Information Ratio", "-13.918"},
             {"Tracking Error", "0.104"},
-            {"Treynor Ratio", "0.932"},
-            {"Total Fees", "$46.20"},
-            {"Estimated Strategy Capacity", "$2300000.00"},
+            {"Treynor Ratio", "0.93"},
+            {"Total Fees", "$40.20"},
+            {"Estimated Strategy Capacity", "$4400000.00"},
             {"Lowest Capacity Asset", "AIG R735QTJ8XC9X"},
-            {"Fitness Score", "0.645"},
-            {"Kelly Criterion Estimate", "13.787"},
-            {"Kelly Criterion Probability Value", "0.231"},
-            {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "65.642"},
-            {"Portfolio Turnover", "0.645"},
-            {"Total Insights Generated", "13"},
-            {"Total Insights Closed", "10"},
-            {"Total Insights Analysis Completed", "10"},
-            {"Long Insight Count", "6"},
-            {"Short Insight Count", "7"},
-            {"Long/Short Ratio", "85.71%"},
-            {"Estimated Monthly Alpha Value", "$52003.0716"},
-            {"Total Accumulated Estimated Alpha Value", "$8956.0846"},
-            {"Mean Population Estimated Insight Value", "$895.6085"},
-            {"Mean Population Direction", "70%"},
-            {"Mean Population Magnitude", "70%"},
-            {"Rolling Averaged Population Direction", "94.5154%"},
-            {"Rolling Averaged Population Magnitude", "94.5154%"},
-            {"OrderListHash", "0945ff7a39bb8f8a07b3dcc817c070aa"}
+            {"Portfolio Turnover", "64.47%"},
+            {"OrderListHash", "b1a3afb0457810d2b512ae48fe3f5a01"}
         };
     }
 }

Algorithm.CSharp/BrokerageActivityEventHandlingAlgorithm.cs

@@ -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.
+*/
+
+using QuantConnect.Brokerages;
+using QuantConnect.Data;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Example algorithm to demostrate the event handlers of Brokerage activities
+    /// </summary>
+    /// <meta name="tag" content="using quantconnect" />
+    public class BrokerageActivityEventHandlingAlgorithm : 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(2013, 10, 07);
+            SetEndDate(2013, 10, 11);
+            SetCash(100000);
+
+            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);
+            }
+        }
+
+        /// <summary>
+        /// Brokerage message event handler. This method is called for all types of brokerage messages.
+        /// </summary>
+        public override void OnBrokerageMessage(BrokerageMessageEvent messageEvent)
+        {
+            Debug($"Brokerage meesage received - {messageEvent.ToString()}");
+        }
+
+        /// <summary>
+        /// Brokerage disconnected event handler. This method is called when the brokerage connection is lost.
+        /// </summary>
+        public override void OnBrokerageDisconnect()
+        {
+            Debug($"Brokerage disconnected!");
+        }
+
+        /// <summary>
+        /// Brokerage reconnected event handler. This method is called when the brokerage connection is restored after a disconnection.
+        /// </summary>
+        public override void OnBrokerageReconnect()
+        {
+            Debug($"Brokerage reconnected!");
+        }
+    }
+}

Algorithm.CSharp/BybitCryptoFuturesRegressionAlgorithm.cs

@@ -0,0 +1,263 @@
+/*
+ * 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.Brokerages;
+using QuantConnect.Indicators;
+using QuantConnect.Orders;
+using QuantConnect.Interfaces;
+using QuantConnect.Securities.CryptoFuture;
+using QuantConnect.Data.Market;
+using QuantConnect.Securities;
+using System.Linq;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Algorithm demonstrating and ensuring that Bybit crypto futures brokerage model works as expected
+    /// </summary>
+    public class BybitCryptoFuturesRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private CryptoFuture _btcUsdt;
+        private CryptoFuture _btcUsd;
+
+        private ExponentialMovingAverage _fast;
+        private ExponentialMovingAverage _slow;
+
+        private Dictionary<Symbol, int> _interestPerSymbol = new();
+
+        public override void Initialize()
+        {
+            SetStartDate(2022, 12, 13);
+            SetEndDate(2022, 12, 13);
+
+            // Set strategy cash (USD)
+            SetCash(100000);
+
+            SetBrokerageModel(BrokerageName.Bybit, AccountType.Margin);
+
+            AddCrypto("BTCUSDT", Resolution.Minute);
+
+            _btcUsdt = AddCryptoFuture("BTCUSDT", Resolution.Minute);
+            _btcUsd = AddCryptoFuture("BTCUSD", Resolution.Minute);
+
+            // create two moving averages
+            _fast = EMA(_btcUsdt.Symbol, 30, Resolution.Minute);
+            _slow = EMA(_btcUsdt.Symbol, 60, Resolution.Minute);
+
+            _interestPerSymbol[_btcUsdt.Symbol] = 0;
+            _interestPerSymbol[_btcUsd.Symbol] = 0;
+
+            // the amount of USDT we need to hold to trade 'BTCUSDT'
+            _btcUsdt.QuoteCurrency.SetAmount(200);
+            // the amount of BTC we need to hold to trade 'BTCUSD'
+            _btcUsd.BaseCurrency.SetAmount(0.005m);
+        }
+
+        public override void OnData(Slice data)
+        {
+            var interestRates = data.Get<MarginInterestRate>();
+            foreach (var interestRate in interestRates)
+            {
+                _interestPerSymbol[interestRate.Key]++;
+
+                var cachedInterestRate = Securities[interestRate.Key].Cache.GetData<MarginInterestRate>();
+                if (cachedInterestRate != interestRate.Value)
+                {
+                    throw new Exception($"Unexpected cached margin interest rate for {interestRate.Key}!");
+                }
+            }
+
+            if (!_slow.IsReady)
+            {
+                return;
+            }
+
+            if (_fast > _slow)
+            {
+                if (!Portfolio.Invested && Transactions.OrdersCount == 0)
+                {
+                    var ticket = Buy(_btcUsd.Symbol, 1000);
+                    if (ticket.Status != OrderStatus.Invalid)
+                    {
+                        throw new Exception($"Unexpected valid order {ticket}, should fail due to margin not sufficient");
+                    }
+
+                    Buy(_btcUsd.Symbol, 100);
+
+                    var marginUsed = Portfolio.TotalMarginUsed;
+                    var btcUsdHoldings = _btcUsd.Holdings;
+
+                    // Coin futures value is 100 USD
+                    var holdingsValueBtcUsd = 100;
+                    if (Math.Abs(btcUsdHoldings.TotalSaleVolume - holdingsValueBtcUsd) > 1)
+                    {
+                        throw new Exception($"Unexpected TotalSaleVolume {btcUsdHoldings.TotalSaleVolume}");
+                    }
+                    if (Math.Abs(btcUsdHoldings.AbsoluteHoldingsCost - holdingsValueBtcUsd) > 1)
+                    {
+                        throw new Exception($"Unexpected holdings cost {btcUsdHoldings.HoldingsCost}");
+                    }
+                    // margin used is based on the maintenance rate
+                    if (Math.Abs(btcUsdHoldings.AbsoluteHoldingsCost * 0.05m - marginUsed) > 1
+                        || _btcUsd.BuyingPowerModel.GetMaintenanceMargin(_btcUsd) != marginUsed)
+                    {
+                        throw new Exception($"Unexpected margin used {marginUsed}");
+                    }
+
+                    Buy(_btcUsdt.Symbol, 0.01);
+
+                    marginUsed = Portfolio.TotalMarginUsed - marginUsed;
+                    var btcUsdtHoldings = _btcUsdt.Holdings;
+
+                    // USDT futures value is based on it's price
+                    var holdingsValueUsdt = _btcUsdt.Price * _btcUsdt.SymbolProperties.ContractMultiplier * 0.01m;
+
+                    if (Math.Abs(btcUsdtHoldings.TotalSaleVolume - holdingsValueUsdt) > 1)
+                    {
+                        throw new Exception($"Unexpected TotalSaleVolume {btcUsdtHoldings.TotalSaleVolume}");
+                    }
+                    if (Math.Abs(btcUsdtHoldings.AbsoluteHoldingsCost - holdingsValueUsdt) > 1)
+                    {
+                        throw new Exception($"Unexpected holdings cost {btcUsdtHoldings.HoldingsCost}");
+                    }
+                    if (Math.Abs(btcUsdtHoldings.AbsoluteHoldingsCost * 0.05m - marginUsed) > 1
+                        || _btcUsdt.BuyingPowerModel.GetMaintenanceMargin(_btcUsdt) != marginUsed)
+                    {
+                        throw new Exception($"Unexpected margin used {marginUsed}");
+                    }
+
+                    // position just opened should be just spread here
+                    var unrealizedProfit = Portfolio.TotalUnrealizedProfit;
+                    if ((5 - Math.Abs(unrealizedProfit)) < 0)
+                    {
+                        throw new Exception($"Unexpected TotalUnrealizedProfit {Portfolio.TotalUnrealizedProfit}");
+                    }
+
+                    if (Portfolio.TotalProfit != 0)
+                    {
+                        throw new Exception($"Unexpected TotalProfit {Portfolio.TotalProfit}");
+                    }
+                }
+            }
+            // let's revert our position
+            else if (Transactions.OrdersCount == 3)
+            {
+                Sell(_btcUsd.Symbol, 300);
+
+                var btcUsdHoldings = _btcUsd.Holdings;
+
+                if (Math.Abs(btcUsdHoldings.AbsoluteHoldingsCost - 100 * 2) > 1)
+                {
+                    throw new Exception($"Unexpected holdings cost {btcUsdHoldings.HoldingsCost}");
+                }
+
+                Sell(_btcUsdt.Symbol, 0.03);
+
+                var btcUsdtHoldings = _btcUsdt.Holdings;
+
+                // USDT futures value is based on it's price
+                var holdingsValueUsdt = _btcUsdt.Price * _btcUsdt.SymbolProperties.ContractMultiplier * 0.02m;
+
+                if (Math.Abs(btcUsdtHoldings.AbsoluteHoldingsCost - holdingsValueUsdt) > 1)
+                {
+                    throw new Exception($"Unexpected holdings cost {btcUsdtHoldings.HoldingsCost}");
+                }
+
+                // position just opened should be just spread here
+                var profit = Portfolio.TotalUnrealizedProfit;
+                if ((5 - Math.Abs(profit)) < 0)
+                {
+                    throw new Exception($"Unexpected TotalUnrealizedProfit {Portfolio.TotalUnrealizedProfit}");
+                }
+                // we barely did any difference on the previous trade
+                if ((5 - Math.Abs(Portfolio.TotalProfit)) < 0)
+                {
+                    throw new Exception($"Unexpected TotalProfit {Portfolio.TotalProfit}");
+                }
+            }
+        }
+
+        public override void OnOrderEvent(OrderEvent orderEvent)
+        {
+            Debug(Time + " " + orderEvent);
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            Log($"{Time} - TotalPortfolioValue: {Portfolio.TotalPortfolioValue}");
+            Log($"{Time} - CashBook: {Portfolio.CashBook}");
+
+            if (_interestPerSymbol.Any(kvp => kvp.Value == 0))
+            {
+                throw new Exception("Expected interest rate data for all symbols");
+            }
+        }
+
+        /// <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>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 8625;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public int AlgorithmHistoryDataPoints => 60;
+
+        /// <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", "0%"},
+            {"Drawdown", "0%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "0%"},
+            {"Sharpe Ratio", "0"},
+            {"Sortino 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.60"},
+            {"Estimated Strategy Capacity", "$200000000.00"},
+            {"Lowest Capacity Asset", "BTCUSDT 2V3"},
+            {"Portfolio Turnover", "1.08%"},
+            {"OrderListHash", "114cfc5cfe796850f7ac29c2e63407d6"}
+        };
+    }
+}

Algorithm.CSharp/BybitCryptoRegressionAlgorithm.cs

@@ -0,0 +1,172 @@
+/*
+ * 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.Brokerages;
+using QuantConnect.Indicators;
+using QuantConnect.Orders;
+using QuantConnect.Interfaces;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Algorithm demonstrating and ensuring that Bybit crypto brokerage model works as expected
+    /// </summary>
+    public class BybitCryptoRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Symbol _btcUsdt;
+
+        private ExponentialMovingAverage _fast;
+        private ExponentialMovingAverage _slow;
+
+        private bool _liquidated;
+
+        public override void Initialize()
+        {
+            SetStartDate(2022, 12, 13);
+            SetEndDate(2022, 12, 13);
+
+            // Set account currency (USDT)
+            SetAccountCurrency("USDT");
+
+            // Set strategy cash (USD)
+            SetCash(100000);
+
+            // Add some coin as initial holdings
+            // When connected to a real brokerage, the amount specified in SetCash
+            // will be replaced with the amount in your actual account.
+            SetCash("BTC", 1m);
+
+            SetBrokerageModel(BrokerageName.Bybit, AccountType.Cash);
+
+            _btcUsdt = AddCrypto("BTCUSDT").Symbol;
+
+            // create two moving averages
+            _fast = EMA(_btcUsdt, 30, Resolution.Minute);
+            _slow = EMA(_btcUsdt, 60, Resolution.Minute);
+        }
+
+        public override void OnData(Slice data)
+        {
+            if (Portfolio.CashBook["USDT"].ConversionRate == 0 || Portfolio.CashBook["BTC"].ConversionRate == 0)
+            {
+                Log($"USDT conversion rate: {Portfolio.CashBook["USDT"].ConversionRate}");
+                Log($"BTC conversion rate: {Portfolio.CashBook["BTC"].ConversionRate}");
+
+                throw new Exception("Conversion rate is 0");
+            }
+
+            if (!_slow.IsReady)
+            {
+                return;
+            }
+
+
+            var btcAmount = Portfolio.CashBook["BTC"].Amount;
+            if (_fast > _slow)
+            {
+                if (btcAmount == 1m && !_liquidated)
+                {
+                    Buy(_btcUsdt, 1);
+                }
+            }
+            else
+            {
+                if (btcAmount > 1m)
+                {
+                    Liquidate(_btcUsdt);
+                    _liquidated = true;
+                }
+                else if (btcAmount > 0 && _liquidated && Transactions.GetOpenOrders().Count == 0)
+                {
+                    // Place a limit order to sell our initial BTC holdings at 1% above the current price
+                    var limitPrice = Math.Round(Securities[_btcUsdt].Price * 1.01m, 2);
+                    LimitOrder(_btcUsdt, -btcAmount, limitPrice);
+                }
+            }
+        }
+
+        public override void OnOrderEvent(OrderEvent orderEvent)
+        {
+            Debug(Time + " " + orderEvent);
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            Log($"{Time} - TotalPortfolioValue: {Portfolio.TotalPortfolioValue}");
+            Log($"{Time} - CashBook: {Portfolio.CashBook}");
+
+            var btcAmount = Portfolio.CashBook["BTC"].Amount;
+            if (btcAmount > 0)
+            {
+                throw new Exception($"BTC holdings should be zero at the end of the algorithm, but was {btcAmount}");
+            }
+        }
+
+        /// <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>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 2883;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public int AlgorithmHistoryDataPoints => 60;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        {
+            {"Total Trades", "3"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "0%"},
+            {"Drawdown", "0%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "0%"},
+            {"Sharpe Ratio", "0"},
+            {"Sortino 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", "₮51.65"},
+            {"Estimated Strategy Capacity", "₮560000.00"},
+            {"Lowest Capacity Asset", "BTCUSDT 2UZ"},
+            {"Portfolio Turnover", "44.04%"},
+            {"OrderListHash", "b3a9eb7392ba1eb7eb0cc387f7382b6c"}
+        };
+    }
+}

Algorithm.CSharp/BybitCustomDataCryptoRegressionAlgorithm.cs

@@ -0,0 +1,184 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
+using System;
+using System.Collections.Generic;
+using QuantConnect.Data;
+using QuantConnect.Brokerages;
+using QuantConnect.Indicators;
+using QuantConnect.Interfaces;
+using System.IO;
+using QuantConnect.Orders;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Algorithm demonstrating and ensuring that Bybit crypto brokerage model works as expected with custom data types
+    /// </summary>
+    public class BybitCustomDataCryptoRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Symbol _btcUsdt;
+
+        private ExponentialMovingAverage _fast;
+        private ExponentialMovingAverage _slow;
+
+        public override void Initialize()
+        {
+            SetStartDate(2022, 12, 13);
+            SetEndDate(2022, 12, 13);
+
+            SetAccountCurrency("USDT");
+            SetCash(100000);
+
+            SetBrokerageModel(BrokerageName.Bybit, AccountType.Cash);
+
+            var symbol = AddCrypto("BTCUSDT").Symbol;
+            _btcUsdt = AddData<CustomCryptoData>(symbol, Resolution.Minute).Symbol;
+
+            // create two moving averages
+            _fast = EMA(_btcUsdt, 30, Resolution.Minute);
+            _slow = EMA(_btcUsdt, 60, Resolution.Minute);
+        }
+
+        public override void OnData(Slice data)
+        {
+            if (!_slow.IsReady)
+            {
+                return;
+            }
+
+            if (_fast > _slow)
+            {
+                if (Transactions.OrdersCount == 0)
+                {
+                    Buy(_btcUsdt, 1);
+                }
+            }
+            else
+            {
+                if (Transactions.OrdersCount == 1)
+                {
+                    Liquidate(_btcUsdt);
+                }
+            }
+        }
+
+        public override void OnOrderEvent(OrderEvent orderEvent)
+        {
+            Debug(Time + " " + orderEvent);
+        }
+
+        public class CustomCryptoData : BaseData
+        {
+            public decimal Open;
+            public decimal High;
+            public decimal Low;
+            public decimal Close;
+            public decimal Volume;
+
+            public override DateTime EndTime
+            {
+                get { return Time + Period; }
+                set { Time = value - Period; }
+            }
+
+            public TimeSpan Period
+            {
+                get { return QuantConnect.Time.OneMinute; }
+            }
+
+            public override SubscriptionDataSource GetSource(SubscriptionDataConfig config, DateTime date, bool isLiveMode)
+            {
+                var tickTypeString = config.TickType.TickTypeToLower();
+                var formattedDate = date.ToStringInvariant(DateFormat.EightCharacter);
+                var source = Path.Combine(Globals.DataFolder, "crypto", "bybit", config.Resolution.ToString().ToLower(),
+                    config.Symbol.Value.ToLower(), $"{formattedDate}_{tickTypeString}.zip");
+
+                return new SubscriptionDataSource(source, SubscriptionTransportMedium.LocalFile, FileFormat.Csv);
+            }
+
+            public override BaseData Reader(SubscriptionDataConfig config, string line, DateTime date, bool isLiveMode)
+            {
+                var csv = line.ToCsv(6);
+
+                var data = new CustomCryptoData
+                {
+                    Symbol = config.Symbol,
+                    Time = date.Date.AddMilliseconds(csv[0].ToInt32()).ConvertTo(config.DataTimeZone, config.ExchangeTimeZone),
+                    Open = csv[1].ToDecimal(),
+                    High = csv[2].ToDecimal(),
+                    Low = csv[3].ToDecimal(),
+                    Close = csv[4].ToDecimal(),
+                    Volume = csv[5].ToDecimal(),
+                    Value = csv[4].ToDecimal()
+                };
+
+                return 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, Language.Python };
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 4324;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public int AlgorithmHistoryDataPoints => 60;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        {
+            {"Total Trades", "2"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "0%"},
+            {"Drawdown", "0%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "0%"},
+            {"Sharpe Ratio", "0"},
+            {"Sortino 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"},
+            {"Estimated Strategy Capacity", "₮0"},
+            {"Lowest Capacity Asset", "BTCUSDT.CustomCryptoData 2US"},
+            {"Portfolio Turnover", "34.30%"},
+            {"OrderListHash", "6d099b57951f4801f9c07fba5f4c9f05"}
+        };
+    }
+}

Algorithm.CSharp/CallingRFromCSharp.cs

@@ -1,70 +0,0 @@
-/*
-  * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
-  * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
-  *
-  * Licensed under the Apache License, Version 2.0 (the "License");
-  * you may not use this file except in compliance with the License.
-  * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
-  *
-  * Unless required by applicable law or agreed to in writing, software
-  * distributed under the License is distributed on an "AS IS" BASIS,
-  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  * See the License for the specific language governing permissions and
-  * limitations under the License.
- */
-
- using QuantConnect.Data;
- using RDotNet;
- using System.Linq;
-
- namespace QuantConnect.Algorithm.CSharp
- {
-    /// <summary>
-    /// Demonstration of the R-integration for calling external statistics operations in QuantConnect.
-    /// </summary>
-    /// <meta name="tag" content="using r" />
-    /// <meta name="tag" content="statistics libraries" />
-    public class CallingRFromCSharp : QCAlgorithm
-     {
-         private Symbol _spy = QuantConnect.Symbol.Create("SPY", SecurityType.Equity, Market.USA);
-
-         /// <summary>
-         /// Initialise the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must initialized.
-         /// </summary>
-         public override void Initialize()
-         {
-             SetStartDate(2013, 10, 07);  //Set Start Date
-             SetEndDate(2013, 10, 11);    //Set End Date
-             SetCash(100000);             //Set Strategy Cash
-             // Find more symbols here: http://quantconnect.com/data
-             AddEquity("SPY", Resolution.Second);
-
-             var engine = REngine.GetInstance();
-             engine.Evaluate("print('This is from R command.')");
-             // .NET Framework array to R vector.
-             var group1 = engine.CreateNumericVector(new double[] { 30.02, 29.99, 30.11, 29.97, 30.01, 29.99 });
-             engine.SetSymbol("group1", group1);
-             // Direct parsing from R script.
-             var group2 = engine.Evaluate("group2 <- c(29.89, 29.93, 29.72, 29.98, 30.02, 29.98)").AsNumeric();
-             // Test difference of mean and get the P-value.
-             var testResult = engine.Evaluate("t.test(group1, group2)").AsList();
-             var p = testResult["p.value"].AsNumeric().First();
-             // you should always dispose of the REngine properly.
-             // After disposing of the engine, you cannot reinitialize nor reuse it
-             engine.Dispose();
-
-         }
-
-         /// <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);
-             }
-         }
-     }
- }

Algorithm.CSharp/CancelOpenOrdersRegressionAlgorithm.cs

@@ -145,6 +145,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Expectancy", "0"},
             {"Net Profit", "0%"},
             {"Sharpe Ratio", "0"},
+            {"Sortino Ratio", "0"},
             {"Probabilistic Sharpe Ratio", "0%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
@@ -158,27 +159,9 @@ namespace QuantConnect.Algorithm.CSharp
             {"Treynor Ratio", "0"},
             {"Total Fees", "$0.00"},
             {"Estimated Strategy Capacity", "$370000.00"},
-            {"Lowest Capacity Asset", "ETHUSD XJ"},
-            {"Fitness Score", "0.501"},
-            {"Kelly Criterion Estimate", "0"},
-            {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "-30.158"},
-            {"Portfolio Turnover", "1.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", "aea2e321d17414c1f3c6fa2491f10c88"}
+            {"Lowest Capacity Asset", "ETHUSD 2XR"},
+            {"Portfolio Turnover", "104.59%"},
+            {"OrderListHash", "ec714d818fa30597e992d4c6e939e68c"}
         };
     }
 }

Algorithm.CSharp/CfdTimeZonesRegressionAlgorithm.cs

@@ -92,7 +92,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "0.300%"},
             {"Expectancy", "-0.345"},
             {"Net Profit", "-0.337%"},
-            {"Sharpe Ratio", "-19.772"},
+            {"Sharpe Ratio", "-21.957"},
+            {"Sortino Ratio", "-21.957"},
             {"Probabilistic Sharpe Ratio", "0%"},
             {"Loss Rate", "68%"},
             {"Win Rate", "32%"},
@@ -107,26 +108,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Fees", "€0.00"},
             {"Estimated Strategy Capacity", "€670000.00"},
             {"Lowest Capacity Asset", "DE30EUR 8I"},
-            {"Fitness Score", "0"},
-            {"Kelly Criterion Estimate", "0"},
-            {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "-101.587"},
-            {"Return Over Maximum Drawdown", "-110.633"},
-            {"Portfolio Turnover", "9.513"},
-            {"Total Insights Generated", "0"},
-            {"Total Insights Closed", "0"},
-            {"Total Insights Analysis Completed", "0"},
-            {"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", "64c098abe3c1e7206424b0c3825b0069"}
+            {"Portfolio Turnover", "1062.25%"},
+            {"OrderListHash", "3c15395d3214749b2db83c7e23866224"}
         };
     }
 }

Algorithm.CSharp/ClassicRangeConsolidatorAlgorithm.cs

@@ -0,0 +1,42 @@
+/*
+ * 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.Consolidators;
+using QuantConnect.Data.Market;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Example algorithm of how to use the ClassicRangeConsolidator
+    /// </summary>
+    public class ClassicRangeConsolidatorAlgorithm : RangeConsolidatorAlgorithm
+    {
+        protected override RangeConsolidator CreateRangeConsolidator()
+        {
+            return new ClassicRangeConsolidator(Range);
+        }
+
+        protected override void OnDataConsolidated(Object sender, RangeBar rangeBar)
+        {
+            base.OnDataConsolidated(sender, rangeBar);
+
+            if (rangeBar.Volume == 0)
+            {
+                throw new Exception($"All RangeBar's should have non-zero volume, but this doesn't");
+            }
+        }
+    }
+}

Algorithm.CSharp/ClassicRangeConsolidatorWithTickAlgorithm.cs

@@ -0,0 +1,42 @@
+/*
+ * 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.Consolidators;
+using QuantConnect.Data.Market;
+using System;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Example algorithm of how to use ClassicRangeConsolidator with Tick resolution
+    /// </summary>
+    public class ClassicRangeConsolidatorWithTickAlgorithm : RangeConsolidatorWithTickAlgorithm
+    {
+        protected override RangeConsolidator CreateRangeConsolidator()
+        {
+            return new ClassicRangeConsolidator(Range);
+        }
+
+        protected override void OnDataConsolidated(Object sender, RangeBar rangeBar)
+        {
+            base.OnDataConsolidated(sender, rangeBar);
+
+            if (rangeBar.Volume == 0)
+            {
+                throw new Exception($"All RangeBar's should have non-zero volume, but this doesn't");
+            }
+        }
+    }
+}

Algorithm.CSharp/ClassicRenkoConsolidatorAlgorithm.cs

@@ -129,45 +129,28 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "29"},
             {"Average Win", "1.85%"},
             {"Average Loss", "-1.49%"},
-            {"Compounding Annual Return", "7.819%"},
+            {"Compounding Annual Return", "7.817%"},
             {"Drawdown", "6.800%"},
             {"Expectancy", "0.281"},
-            {"Net Profit", "7.841%"},
-            {"Sharpe Ratio", "0.799"},
-            {"Probabilistic Sharpe Ratio", "39.344%"},
+            {"Net Profit", "7.839%"},
+            {"Sharpe Ratio", "0.692"},
+            {"Sortino Ratio", "0.636"},
+            {"Probabilistic Sharpe Ratio", "39.336%"},
             {"Loss Rate", "43%"},
             {"Win Rate", "57%"},
             {"Profit-Loss Ratio", "1.24"},
-            {"Alpha", "0.009"},
+            {"Alpha", "0.004"},
             {"Beta", "0.411"},
             {"Annual Standard Deviation", "0.07"},
             {"Annual Variance", "0.005"},
-            {"Information Ratio", "-0.703"},
+            {"Information Ratio", "-0.704"},
             {"Tracking Error", "0.083"},
-            {"Treynor Ratio", "0.136"},
-            {"Total Fees", "$129.35"},
+            {"Treynor Ratio", "0.118"},
+            {"Total Fees", "$129.34"},
             {"Estimated Strategy Capacity", "$1000000000.00"},
             {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
-            {"Fitness Score", "0.062"},
-            {"Kelly Criterion Estimate", "0"},
-            {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "1.023"},
-            {"Return Over Maximum Drawdown", "1.142"},
-            {"Portfolio Turnover", "0.094"},
-            {"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", "b2286d2421294408c3a390e614f40ef9"}
+            {"Portfolio Turnover", "7.91%"},
+            {"OrderListHash", "b9aded02d28fb04cfe7ecadc08cac6e9"}
         };
     }
 }