Update readme.md

* feat: gdax -> coinbase

* feat: defaultBrokerageModel gdax -> coinbase

* refactor: coinbaseBrokerageModel
fix: gdax test

* feat: add coinbase market hours

* feat: symbolPropDB gdax -> coinbase

* fix: gdax to coinbase tests

* fix: coinbase Fees data

* remove: gdax market-hours

* revert: stopMarket order Type by date + test

* fix: coinbase test (fee was changed)
revert: old test with stopMarket gdax
fix: pandas padding

* refactor: gdaxLiveTrading -> CoinbaseLiveTrading
remove: gdax configs

* remove: old gdax testdata files

* refactor: gdax route -> coinbase route
feat: add deprecated gdax info
feat: some string "gdax" -> "coinbase"

* fix: style brackets

* fix: config coinbase data-queue-handler

* revert: public StablePairsGDAX collection

* rename: GdaxBrokerageModel to CoinbaseBrokerageModel in tests
rename: gdax -> coinbase in DefaultMarketMap
rename: gdaxBrokerageModelTest to Coinbase...

* revert: coinbase changes in toolbox (deprecated)

* remove: override Clone() in GDAX\Coinbase-OrderProperties

* typo: ops missing brackets

* rename: Market.Gdax -> Coinbase in Test
remove: ref on gdax

* test: compatibility of GDAXOrderProperties

* fix: coinbase brokerageName enum number

* feat: readonly to stablePairs Gdax/Coinbase
remove: GetFeeModel() in GDAXBrokerageModel {}

* test: gdax market name compatible with coinbase

* rename: config to old ones

* feat: coinbase CanUpdateOrder()

* rename: plus to commit 4135c91

* feat: coinbase fee model + test

* fix: stable fees data

* update: coinbase symbol-properties-database.csv

* fix:  validation of MinimumOrderSize in SubmitOrder()

* feat: gdax -> coinbase

* feat: defaultBrokerageModel gdax -> coinbase

* refactor: coinbaseBrokerageModel
fix: gdax test

* feat: add coinbase market hours

* feat: symbolPropDB gdax -> coinbase

* fix: gdax to coinbase tests

* fix: coinbase Fees data

* remove: gdax market-hours

* revert: stopMarket order Type by date + test

* fix: coinbase test (fee was changed)
revert: old test with stopMarket gdax
fix: pandas padding

* refactor: gdaxLiveTrading -> CoinbaseLiveTrading
remove: gdax configs

* remove: old gdax testdata files

* refactor: gdax route -> coinbase route
feat: add deprecated gdax info
feat: some string "gdax" -> "coinbase"

* fix: style brackets

* fix: config coinbase data-queue-handler

* revert: public StablePairsGDAX collection

* rename: GdaxBrokerageModel to CoinbaseBrokerageModel in tests
rename: gdax -> coinbase in DefaultMarketMap
rename: gdaxBrokerageModelTest to Coinbase...

* revert: coinbase changes in toolbox (deprecated)

* remove: override Clone() in GDAX\Coinbase-OrderProperties

* typo: ops missing brackets

* rename: Market.Gdax -> Coinbase in Test
remove: ref on gdax

* test: compatibility of GDAXOrderProperties

* fix: coinbase brokerageName enum number

* feat: readonly to stablePairs Gdax/Coinbase
remove: GetFeeModel() in GDAXBrokerageModel {}

* test: gdax market name compatible with coinbase

* rename: config to old ones

* feat: coinbase CanUpdateOrder()

* rename: plus to commit 4135c91

* feat: coinbase fee model + test

* fix: stable fees data

* update: coinbase symbol-properties-database.csv

* fix:  validation of MinimumOrderSize in SubmitOrder()

* fix: skipped gdax name to coinbase

* feature: visible Symbol prop in DefaultOrderBook

.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/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 --blame-hang-timeout 300seconds --blame-crash --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,61 +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" --blame-hang-timeout 120seconds --blame-crash
-
-      - name: Run Pomegranate & Tigramite Python Package Test
-        run: dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests.PomegranateTest|Tigramite" --blame-hang-timeout 120seconds --blame-crash
-
-      - name: Run StableBaselines Python Package Test
-        run: dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests.StableBaselinesTest" --blame-hang-timeout 120seconds --blame-crash
-
-      - name: Run AxPlatform Python Package Test
-        run: dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests.AxPlatformTest" --blame-hang-timeout 120seconds --blame-crash
-
-      - name: Run NBeats Python Package Test
-        run: dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests.NBeatsTest" --blame-hang-timeout 120seconds --blame-crash
-
-      - name: Run TensorlyTest Python Package Test
-        run: dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests.TensorlyTest" --blame-hang-timeout 120seconds --blame-crash
-
-      - name: Run NeuralTangents, Ignite Python Package Test
-        run: dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests.NeuralTangentsTest|IgniteTest" --blame-hang-timeout 120seconds --blame-crash
-
-      - name: Run TensorflowTest
-        run: dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests.TensorflowTest" --blame-hang-timeout 120seconds --blame-crash
-
-      - name: Run TensorflowProbability
-        run: dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests.TensorflowProbabilityTest" --blame-hang-timeout 120seconds --blame-crash
-
-      - name: Run Hvplot Python Package Test
-        run: dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests.HvplotTest" --blame-hang-timeout 120seconds --blame-crash
-
-      - name: Run Hvplot Python Package Test
-        run: dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests.StellargraphTest" --blame-hang-timeout 120seconds --blame-crash
-
-      - name: Run Keras Python Package Test
-        run: dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests.KerasTest" --blame-hang-timeout 120seconds --blame-crash
-
-      - name: Run Keras Python Package Test
-        run: dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests.ScikerasTest" --blame-hang-timeout 120seconds --blame-crash
+      - 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

.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,23 +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"},
             {"Portfolio Turnover", "119.89%"},
-            {"OrderListHash", "3c4c4085810cc5ecdb927d3647b9bbf3"}
+            {"OrderListHash", "2b4c6d1cb2fc32e25f9a744e8aa7229a"}
         };
     }
 }

Algorithm.CSharp/AddAlphaModelAlgorithm.cs

@@ -127,23 +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"},
             {"Portfolio Turnover", "41.18%"},
-            {"OrderListHash", "9da9afe1e9137638a55db1676adc2be1"}
+            {"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%"},

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%"},

Algorithm.CSharp/AddBetaIndicatorRegressionAlgorithm.cs

@@ -121,23 +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"},
             {"Portfolio Turnover", "1.51%"},
-            {"OrderListHash", "bd88c6a0e10c7e146b05377205101a12"}
+            {"OrderListHash", "e930f95771bc50dd2db1c353e054c4e7"}
         };
     }
 }

Algorithm.CSharp/AddFutureContractWithContinuousRegressionAlgorithm.cs

@@ -135,23 +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"},
             {"Portfolio Turnover", "66.80%"},
-            {"OrderListHash", "802a335b5c355e83b8cd2174f053c1b9"}
+            {"OrderListHash", "0ade3a7a7aaafa3263082c93cf17c4d8"}
         };
     }
 }

Algorithm.CSharp/AddFutureOptionContractDataStreamingRegressionAlgorithm.cs

@@ -183,23 +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"},
             {"Portfolio Turnover", "122.11%"},
-            {"OrderListHash", "e7021bd385f366771ae00abd3a46a22e"}
+            {"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"},
@@ -128,7 +129,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$2600000.00"},
             {"Lowest Capacity Asset", "ES 31C3JQS9D84PW|ES XCZJLC9NOB29"},
             {"Portfolio Turnover", "495.15%"},
-            {"OrderListHash", "64221a660525c4259d5bd852eef1299c"}
+            {"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 => 612882;
+        public long DataPoints => 608372;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -239,23 +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"},
             {"Portfolio Turnover", "32.31%"},
-            {"OrderListHash", "738240babf741f1bf79f85ea5026ec4c"}
+            {"OrderListHash", "b508146aff4ac449e9c6f502928e2115"}
         };
     }
 }

Algorithm.CSharp/AddOptionContractExpiresRegressionAlgorithm.cs

@@ -136,23 +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"},
             {"Portfolio Turnover", "0.55%"},
-            {"OrderListHash", "568fe7c2a11960436660db1231f2cfd2"}
+            {"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,23 +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"},
             {"Portfolio Turnover", "1.14%"},
-            {"OrderListHash", "ae0b430e9c728966e3736fb352a689c6"}
+            {"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%"},
@@ -151,7 +152,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$30000.00"},
             {"Lowest Capacity Asset", "AAPL VXBK4Q9ZIFD2|AAPL R735QTJ8XC9X"},
             {"Portfolio Turnover", "0.07%"},
-            {"OrderListHash", "546b6182e1df2d222178454d8f311566"}
+            {"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 => 6023980;
+        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%"},

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,10 +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"},
-            {"Portfolio Turnover", "1.19%"},
-            {"OrderListHash", "550a99c482106defd8ba15f48183768e"}
+            {"Portfolio Turnover", "1.49%"},
+            {"OrderListHash", "3adcc7ebf4153baabb073a8152e8cb2b"}
         };
     }
 }

Algorithm.CSharp/AddRemoveSecurityCacheRegressionAlgorithm.cs

@@ -102,23 +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"},
             {"Portfolio Turnover", "20.49%"},
-            {"OrderListHash", "6ee62edf1ac883882b0fcef8cb3e9bae"}
+            {"OrderListHash", "48d8e1195003665a2febf547c075d07f"}
         };
     }
 }

Algorithm.CSharp/AddRemoveSecurityRegressionAlgorithm.cs

@@ -128,23 +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"},
             {"Portfolio Turnover", "29.88%"},
-            {"OrderListHash", "ac3f4dfcdeb98b488b715412ad2d6c4f"}
+            {"OrderListHash", "b26f2f30082b754b065c41bb0ace44cc"}
         };
     }
 }

Algorithm.CSharp/AddRiskManagementAlgorithm.cs

@@ -81,23 +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"},
             {"Portfolio Turnover", "59.74%"},
-            {"OrderListHash", "af3a9c98c190d1b6b36fad184e796b0b"}
+            {"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%"},
@@ -136,7 +137,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$230000.00"},
             {"Lowest Capacity Asset", "AAPL VXBK4QQIRLZA|AAPL R735QTJ8XC9X"},
             {"Portfolio Turnover", "0.25%"},
-            {"OrderListHash", "228194dcc6fd8689a67f383577ee2d85"}
+            {"OrderListHash", "afec48c499382b1d01af22daafe9f648"}
         };
     }
 }

Algorithm.CSharp/AddUniverseSelectionModelAlgorithm.cs

@@ -93,30 +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"},
-            {"Portfolio Turnover", "26.96%"},
-            {"OrderListHash", "a7a0983c8413ff241e7d223438f3d508"}
+            {"Portfolio Turnover", "26.92%"},
+            {"OrderListHash", "be09b39c5d01b0694f474ea7f7c5ae09"}
         };
     }
 }

Algorithm.CSharp/AddUniverseSelectionModelCoarseAlgorithm.cs

@@ -104,30 +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"},
-            {"Portfolio Turnover", "7.34%"},
-            {"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%"},
@@ -191,7 +192,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$42000000.00"},
             {"Lowest Capacity Asset", "AAPL R735QTJ8XC9X"},
             {"Portfolio Turnover", "99.56%"},
-            {"OrderListHash", "18e41dded4f8cee548ee02b03ffb0814"}
+            {"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>
@@ -184,12 +235,12 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// This is used by the regression test system to indicate which languages this algorithm is written in.
         /// </summary>
-        public Language[] Languages { get; } = { Language.CSharp, Language.Python };
+        public Language[] Languages { get; } = { Language.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,23 +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"},
             {"Portfolio Turnover", "10.61%"},
-            {"OrderListHash", "0069f402ffcd2d91b9018b81badfab81"}
+            {"OrderListHash", "9c129e856afe96579b52cbfe95237100"}
         };
     }
 }

Algorithm.CSharp/AlphaStreamsBasicTemplateAlgorithm.cs

@@ -88,6 +88,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Expectancy", "-1"},
             {"Net Profit", "-0.116%"},
             {"Sharpe Ratio", "0"},
+            {"Sortino Ratio", "0"},
             {"Probabilistic Sharpe Ratio", "0%"},
             {"Loss Rate", "100%"},
             {"Win Rate", "0%"},
@@ -103,7 +104,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$83000.00"},
             {"Lowest Capacity Asset", "BTCUSD XJ"},
             {"Portfolio Turnover", "2.31%"},
-            {"OrderListHash", "2b94bc50a74caebe06c075cdab1bc6da"}
+            {"OrderListHash", "6912c537884a8c66542f24a2e4e2e6ec"}
         };
     }
 }

Algorithm.CSharp/AlphaStreamsDifferentAccountCurrencyBasicTemplateAlgorithm.cs

@@ -63,7 +63,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "3.100%"},
             {"Expectancy", "7.797"},
             {"Net Profit", "-1.134%"},
-            {"Sharpe Ratio", "-2.456"},
+            {"Sharpe Ratio", "-2.522"},
+            {"Sortino Ratio", "0"},
             {"Probabilistic Sharpe Ratio", "0%"},
             {"Loss Rate", "50%"},
             {"Win Rate", "50%"},
@@ -74,12 +75,12 @@ namespace QuantConnect.Algorithm.CSharp
             {"Annual Variance", "0.117"},
             {"Information Ratio", "-0.859"},
             {"Tracking Error", "0.004"},
-            {"Treynor Ratio", "-0.832"},
+            {"Treynor Ratio", "-0.854"},
             {"Total Fees", "€2.89"},
             {"Estimated Strategy Capacity", "€8900000000.00"},
             {"Lowest Capacity Asset", "AAPL R735QTJ8XC9X"},
             {"Portfolio Turnover", "33.78%"},
-            {"OrderListHash", "a9dd0a0ab6070455479d1b9caaa4e69c"}
+            {"OrderListHash", "2f6f8e5cb06c7b10180258c9f819e76e"}
         };
     }
 }

Algorithm.CSharp/AlphaStreamsUniverseSelectionTemplateAlgorithm.cs

@@ -101,6 +101,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Expectancy", "-1"},
             {"Net Profit", "-0.116%"},
             {"Sharpe Ratio", "0"},
+            {"Sortino Ratio", "0"},
             {"Probabilistic Sharpe Ratio", "0%"},
             {"Loss Rate", "100%"},
             {"Win Rate", "0%"},
@@ -116,7 +117,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$83000.00"},
             {"Lowest Capacity Asset", "BTCUSD XJ"},
             {"Portfolio Turnover", "2.31%"},
-            {"OrderListHash", "2b94bc50a74caebe06c075cdab1bc6da"}
+            {"OrderListHash", "6912c537884a8c66542f24a2e4e2e6ec"}
         };
     }
 }

Algorithm.CSharp/AlphaStreamsWithHoldingsBasicTemplateAlgorithm.cs

@@ -61,7 +61,7 @@ namespace QuantConnect.Algorithm.CSharp
             {
                 var security = Securities["SPY"];
                 var priceInAccountCurrency = Portfolio.CashBook.ConvertToAccountCurrency(security.AskPrice, security.QuoteCurrency.Symbol);
-                _expectedSpyQuantity = (Portfolio.TotalPortfolioValue - Settings.FreePortfolioValue) / priceInAccountCurrency;
+                _expectedSpyQuantity = Portfolio.TotalPortfolioValueLessFreeBuffer / priceInAccountCurrency;
                 _expectedSpyQuantity = _expectedSpyQuantity.DiscretelyRoundBy(1, MidpointRounding.ToZero);
             }
 
@@ -114,23 +114,24 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "3.100%"},
             {"Expectancy", "8.518"},
             {"Net Profit", "-1.515%"},
-            {"Sharpe Ratio", "-2.45"},
+            {"Sharpe Ratio", "-2.515"},
+            {"Sortino Ratio", "0"},
             {"Probabilistic Sharpe Ratio", "0%"},
             {"Loss Rate", "50%"},
             {"Win Rate", "50%"},
             {"Profit-Loss Ratio", "18.04"},
-            {"Alpha", "0.008"},
+            {"Alpha", "0.009"},
             {"Beta", "1.015"},
             {"Annual Standard Deviation", "0.344"},
             {"Annual Variance", "0.118"},
             {"Information Ratio", "-0.856"},
             {"Tracking Error", "0.005"},
-            {"Treynor Ratio", "-0.83"},
+            {"Treynor Ratio", "-0.852"},
             {"Total Fees", "$3.09"},
             {"Estimated Strategy Capacity", "$8900000000.00"},
             {"Lowest Capacity Asset", "AAPL R735QTJ8XC9X"},
             {"Portfolio Turnover", "34.12%"},
-            {"OrderListHash", "788eb2c74715a78476ba0db3b2654eb6"}
+            {"OrderListHash", "6873d205230dda8f9ebe3f6b18a4a1a0"}
         };
     }
 }

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

@@ -0,0 +1,33 @@
+/*
+ * 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.
+*/
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Example algorithm using the asynchronous universe selection functionality
+    /// </summary>
+    public class AsynchronousUniverseRegressionAlgorithm : FundamentalRegressionAlgorithm
+    {
+        /// <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()
+        {
+            base.Initialize();
+
+            UniverseSettings.Asynchronous = true;
+        }
+    }
+}

Algorithm.CSharp/AutoRegressiveIntegratedMovingAverageRegressionAlgorithm.cs

@@ -95,23 +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"},
             {"Portfolio Turnover", "0.02%"},
-            {"OrderListHash", "cf43585a8d1781f04b53a4f1ee3380cb"}
+            {"OrderListHash", "e6711c76cb05bbb575ca067664348d88"}
         };
     }
 }

Algorithm.CSharp/AutomaticIndicatorWarmupDataTypeRegressionAlgorithm.cs

@@ -165,23 +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"},
             {"Portfolio Turnover", "351.80%"},
-            {"OrderListHash", "dd38e7b94027d20942a5aa9ac31a9a7f"}
+            {"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,12 +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"},
             {"Portfolio Turnover", "19.93%"},
-            {"OrderListHash", "9e4bfd2eb0b81ee5bc1b197a87ccedbe"}
+            {"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 => 1341291;
+        public long DataPoints => 1267414;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -315,23 +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"},
             {"Portfolio Turnover", "17.02%"},
-            {"OrderListHash", "85cbf92f01c2c91b5f710b7eeefecbe1"}
+            {"OrderListHash", "a172538bd18fa82b11adaeac4f504b2e"}
         };
     }
 }

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>
@@ -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,9 +106,9 @@ namespace QuantConnect.Algorithm.CSharp
             {"Treynor Ratio", "0"},
             {"Total Fees", "€298.35"},
             {"Estimated Strategy Capacity", "€85000.00"},
-            {"Lowest Capacity Asset", "BTCEUR XJ"},
+            {"Lowest Capacity Asset", "BTCEUR 2XR"},
             {"Portfolio Turnover", "107.64%"},
-            {"OrderListHash", "2ba443899dcccc79dc0f04441f797bf9"}
+            {"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,12 +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"},
             {"Portfolio Turnover", "19.93%"},
-            {"OrderListHash", "9e4bfd2eb0b81ee5bc1b197a87ccedbe"}
+            {"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%"},
@@ -111,7 +105,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$150000000.00"},
             {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
             {"Portfolio Turnover", "4.98%"},
-            {"OrderListHash", "d549c64ee7f5e3866712b3c7dbd64caa"}
+            {"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 => 709638;
+        public long DataPoints => 713394;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -130,30 +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"},
-            {"Portfolio Turnover", "0.92%"},
-            {"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 => 2202510;
+        public long DataPoints => 2217324;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -135,30 +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"},
-            {"Portfolio Turnover", "0.92%"},
-            {"OrderListHash", "adb237703e65b93da5961c0085109732"}
+            {"Portfolio Turnover", "2.34%"},
+            {"OrderListHash", "8a6ad6061fc3c311934a0801c26744eb"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateCryptoAlgorithm.cs

@@ -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,9 +235,9 @@ namespace QuantConnect.Algorithm.CSharp
             {"Treynor Ratio", "0"},
             {"Total Fees", "$85.34"},
             {"Estimated Strategy Capacity", "$0"},
-            {"Lowest Capacity Asset", "BTCEUR XJ"},
+            {"Lowest Capacity Asset", "BTCEUR 2XR"},
             {"Portfolio Turnover", "118.08%"},
-            {"OrderListHash", "1bf1a6d9dd921982b72a6178f9e50e68"}
+            {"OrderListHash", "551b20736f4558a5af5c02b84451fb77"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateCryptoFutureAlgorithm.cs

@@ -45,7 +45,7 @@ namespace QuantConnect.Algorithm.CSharp
             SetStartDate(2022, 12, 13); // Set Start Date
             SetEndDate(2022, 12, 13); // Set End Date
 
-            SetTimeZone(NodaTime.DateTimeZone.Utc);
+            SetTimeZone(TimeZones.Utc);
 
             try
             {
@@ -228,7 +228,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// This is used by the regression test system to indicate which languages this algorithm is written in.
         /// </summary>
-        public Language[] Languages { get; } = { Language.CSharp };
+        public Language[] Languages { get; } = { Language.CSharp, Language.Python };
 
         /// <summary>
         /// Data Points count of all timeslices of algorithm
@@ -253,6 +253,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%"},
@@ -265,10 +266,10 @@ namespace QuantConnect.Algorithm.CSharp
             {"Tracking Error", "0"},
             {"Treynor Ratio", "0"},
             {"Total Fees", "$0.65"},
-            {"Estimated Strategy Capacity", "$630000000.00"},
+            {"Estimated Strategy Capacity", "$500000000.00"},
             {"Lowest Capacity Asset", "ADAUSDT 18R"},
             {"Portfolio Turnover", "0.16%"},
-            {"OrderListHash", "d4520985f69c915060f6bee3b7926cf5"}
+            {"OrderListHash", "ed329700a93491ffe30354769767c6aa"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateCryptoFutureHourlyAlgorithm.cs

@@ -44,7 +44,7 @@ namespace QuantConnect.Algorithm.CSharp
             SetStartDate(2022, 12, 13);
             SetEndDate(2022, 12, 13);
 
-            SetTimeZone(NodaTime.DateTimeZone.Utc);
+            SetTimeZone(TimeZones.Utc);
 
             try
             {
@@ -191,7 +191,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// This is used by the regression test system to indicate which languages this algorithm is written in.
         /// </summary>
-        public Language[] Languages { get; } = { Language.CSharp };
+        public Language[] Languages { get; } = { Language.CSharp, Language.Python };
 
         /// <summary>
         /// Data Points count of all timeslices of algorithm
@@ -216,6 +216,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%"},
@@ -228,10 +229,10 @@ namespace QuantConnect.Algorithm.CSharp
             {"Tracking Error", "0"},
             {"Treynor Ratio", "0"},
             {"Total Fees", "$0.61"},
-            {"Estimated Strategy Capacity", "$520000000.00"},
+            {"Estimated Strategy Capacity", "$370000000.00"},
             {"Lowest Capacity Asset", "ADAUSDT 18R"},
             {"Portfolio Turnover", "0.12%"},
-            {"OrderListHash", "17f99ecc3f35f94fff1ea5694c40d32c"}
+            {"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,12 +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"},
             {"Portfolio Turnover", "10.09%"},
-            {"OrderListHash", "33d01821923c397f999cfb2e5b5928ad"}
+            {"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,12 +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"},
             {"Portfolio Turnover", "59.86%"},
-            {"OrderListHash", "ad2216297c759d8e5aef48ff065f8919"}
+            {"OrderListHash", "75c4c7221e2e70d0aa5c9844aae9009c"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateFutureRolloverAlgorithm.cs

@@ -176,7 +176,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 1345;
+        public long DataPoints => 1333;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -195,23 +195,24 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "0.000%"},
             {"Expectancy", "0"},
             {"Net Profit", "0.528%"},
-            {"Sharpe Ratio", "1.999"},
+            {"Sharpe Ratio", "1.285"},
+            {"Sortino Ratio", "0"},
             {"Probabilistic Sharpe Ratio", "83.704%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "100%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "0.023"},
+            {"Alpha", "0.015"},
             {"Beta", "-0.004"},
             {"Annual Standard Deviation", "0.011"},
             {"Annual Variance", "0"},
             {"Information Ratio", "-4.774"},
             {"Tracking Error", "0.084"},
-            {"Treynor Ratio", "-4.853"},
+            {"Treynor Ratio", "-3.121"},
             {"Total Fees", "$4.30"},
             {"Estimated Strategy Capacity", "$5900000000.00"},
             {"Lowest Capacity Asset", "ES VMKLFZIH2MTD"},
             {"Portfolio Turnover", "0.27%"},
-            {"OrderListHash", "40e4b91ec89383f6501d9ba324e50eb9"}
+            {"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,23 +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"},
             {"Portfolio Turnover", "9912.69%"},
-            {"OrderListHash", "8f92e1528c6477a156449fd1e86527e7"}
+            {"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 => 15217;
+        public virtual long DataPoints => 14036;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -129,30 +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"},
-            {"Portfolio Turnover", "3.15%"},
-            {"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,23 +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"},
             {"Portfolio Turnover", "43.23%"},
-            {"OrderListHash", "323b899ae80aa839e320806411665ce7"}
+            {"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,23 +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"},
             {"Portfolio Turnover", "43.77%"},
-            {"OrderListHash", "18ffd3a774c68da83d867e3b09e3e05d"}
+            {"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%"},

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%"},

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 => 96027;
+        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,23 +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"},
             {"Portfolio Turnover", "17.91%"},
-            {"OrderListHash", "8842e0b890f721371ebf3c25328dee5b"}
+            {"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,23 +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"},
             {"Portfolio Turnover", "32523.20%"},
-            {"OrderListHash", "85cdd035d7c7a3da178d1c2dff31f1bd"}
+            {"OrderListHash", "584fbdabd837921edc6a7e99759b9c66"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateFuturesWithExtendedMarketDailyAlgorithm.cs

@@ -43,37 +43,38 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public override long DataPoints => 17431;
+        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"},
-            {"Portfolio Turnover", "4.07%"},
-            {"OrderListHash", "48bfc4d255420cb589e00cf582554e0a"}
+            {"Portfolio Turnover", "4.16%"},
+            {"OrderListHash", "ce63f5e611a7ab2f49d49c9fdc777ef5"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateFuturesWithExtendedMarketHourlyAlgorithm.cs

@@ -41,37 +41,38 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public override long DataPoints => 248521;
+        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"},
-            {"Portfolio Turnover", "56.49%"},
-            {"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,12 +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"},
             {"Portfolio Turnover", "19.96%"},
-            {"OrderListHash", "f409be3a7c63d9c1394c2e6c005a15ee"}
+            {"OrderListHash", "0f357e8eeee4108d6b53f2b671e97f29"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateIndexAlgorithm.cs

@@ -125,29 +125,30 @@ namespace QuantConnect.Algorithm.CSharp
         public virtual Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
             {"Total Trades", "3"},
-            {"Average Win", "0%"},
-            {"Average Loss", "-2.45%"},
-            {"Compounding Annual Return", "-62.036%"},
-            {"Drawdown", "9.300%"},
-            {"Expectancy", "-1"},
-            {"Net Profit", "-3.051%"},
-            {"Sharpe Ratio", "-4.466"},
-            {"Probabilistic Sharpe Ratio", "0.781%"},
-            {"Loss Rate", "100%"},
-            {"Win Rate", "0%"},
+            {"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.172"},
-            {"Beta", "0.076"},
-            {"Annual Standard Deviation", "0.029"},
+            {"Alpha", "-0.226"},
+            {"Beta", "0.02"},
+            {"Annual Standard Deviation", "0.034"},
             {"Annual Variance", "0.001"},
-            {"Information Ratio", "-6.723"},
-            {"Tracking Error", "0.099"},
-            {"Treynor Ratio", "-1.733"},
+            {"Information Ratio", "-7.032"},
+            {"Tracking Error", "0.107"},
+            {"Treynor Ratio", "-10.906"},
             {"Total Fees", "$0.00"},
-            {"Estimated Strategy Capacity", "$9100000.00"},
+            {"Estimated Strategy Capacity", "$3000.00"},
             {"Lowest Capacity Asset", "SPX XL80P3GHDZXQ|SPX 31"},
-            {"Portfolio Turnover", "24.90%"},
-            {"OrderListHash", "905811fc779835bf0c514963a20e40f9"}
+            {"Portfolio Turnover", "24.07%"},
+            {"OrderListHash", "d1987f604e6d61584838ccc94adf7256"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateIndexHourlyAlgorithm.cs

@@ -42,23 +42,24 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "1.800%"},
             {"Expectancy", "-0.402"},
             {"Net Profit", "-0.922%"},
-            {"Sharpe Ratio", "-2.856"},
+            {"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.155"},
+            {"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.089"},
+            {"Treynor Ratio", "-6.189"},
             {"Total Fees", "$0.00"},
-            {"Estimated Strategy Capacity", "$200000.00"},
+            {"Estimated Strategy Capacity", "$300000.00"},
             {"Lowest Capacity Asset", "SPX XL80P3GHDZXQ|SPX 31"},
             {"Portfolio Turnover", "24.63%"},
-            {"OrderListHash", "9e974939d13fd3255c6291a65d2c1eb9"}
+            {"OrderListHash", "380076bc7854977f46318e8add9f1a25"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateIndexOptionsHourlyAlgorithm.cs

@@ -57,23 +57,24 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "0.000%"},
             {"Expectancy", "-0.486"},
             {"Net Profit", "0.000%"},
-            {"Sharpe Ratio", "-1.628"},
+            {"Sharpe Ratio", "-101.77"},
+            {"Sortino Ratio", "-9053542.758"},
             {"Probabilistic Sharpe Ratio", "17.439%"},
             {"Loss Rate", "97%"},
             {"Win Rate", "3%"},
             {"Profit-Loss Ratio", "17.50"},
-            {"Alpha", "-0"},
+            {"Alpha", "-0.003"},
             {"Beta", "-0"},
             {"Annual Standard Deviation", "0"},
             {"Annual Variance", "0"},
             {"Information Ratio", "-0.449"},
             {"Tracking Error", "0.138"},
-            {"Treynor Ratio", "1.87"},
+            {"Treynor Ratio", "116.921"},
             {"Total Fees", "$0.00"},
             {"Estimated Strategy Capacity", "$0"},
             {"Lowest Capacity Asset", "SPX XL80P59H5E6M|SPX 31"},
             {"Portfolio Turnover", "0.00%"},
-            {"OrderListHash", "0df3713aeb32e9c0738200f2a109e2f9"}
+            {"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%"},
@@ -120,7 +121,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "₹61000000000.00"},
             {"Lowest Capacity Asset", "YESBANK UL"},
             {"Portfolio Turnover", "0.00%"},
-            {"OrderListHash", "6cc69218edd7bd461678b9ee0c575db5"}
+            {"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,10 +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"},
             {"Portfolio Turnover", "0.04%"},
-            {"OrderListHash", "4637f26543287548b28a3c296db055d3"}
+            {"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 => 475788;
+        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,11 +134,11 @@ namespace QuantConnect.Algorithm.CSharp
             {"Information Ratio", "0"},
             {"Tracking Error", "0"},
             {"Treynor Ratio", "0"},
-            {"Total Fees", "$75.00"},
-            {"Estimated Strategy Capacity", "$84000.00"},
+            {"Total Fees", "$26.00"},
+            {"Estimated Strategy Capacity", "$70000.00"},
             {"Lowest Capacity Asset", "GOOCV W78ZERHAOVVQ|GOOCV VP83T1ZUHROL"},
-            {"Portfolio Turnover", "61.34%"},
-            {"OrderListHash", "cee5cc2b0f80c308b496cac0b8668163"}
+            {"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 => 476196;
+        public long DataPoints => 471124;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -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,11 +144,11 @@ namespace QuantConnect.Algorithm.CSharp
             {"Information Ratio", "0"},
             {"Tracking Error", "0"},
             {"Treynor Ratio", "0"},
-            {"Total Fees", "$418.00"},
+            {"Total Fees", "$543.40"},
             {"Estimated Strategy Capacity", "$3000.00"},
             {"Lowest Capacity Asset", "GOOCV W78ZFMEBBB2E|GOOCV VP83T1ZUHROL"},
-            {"Portfolio Turnover", "338.56%"},
-            {"OrderListHash", "e0289a2989c91934656ff7e578f5e810"}
+            {"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 => 475777;
+        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%"},
@@ -144,7 +145,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$1300000.00"},
             {"Lowest Capacity Asset", "GOOCV 30AKMEIPOSS1Y|GOOCV VP83T1ZUHROL"},
             {"Portfolio Turnover", "10.71%"},
-            {"OrderListHash", "838e313ba57850227ec810ed8fb85a23"}
+            {"OrderListHash", "6b2f02d5cedb870e539a7bfb967c777f"}
         };
     }
 }

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);
@@ -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,10 +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"},
             {"Portfolio Turnover", "0.05%"},
-            {"OrderListHash", "0b52bbe98ade8e3aab943e64fcf4abfe"}
+            {"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 => 1322413;
+        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%"},
@@ -135,7 +136,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$0"},
             {"Lowest Capacity Asset", "GOOCV VP83T1ZUHROL"},
             {"Portfolio Turnover", "15.08%"},
-            {"OrderListHash", "0f8537495f5744c02191656d6b3f9205"}
+            {"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"},
@@ -174,7 +175,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$0"},
             {"Lowest Capacity Asset", "AAPL R735QTJ8XC9X"},
             {"Portfolio Turnover", "13.46%"},
-            {"OrderListHash", "83c9fb13ee32284702779eff8d11c608"}
+            {"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,23 +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"},
             {"Portfolio Turnover", "2.28%"},
-            {"OrderListHash", "81e8a822d43de2165c1d3f52964ec312"}
+            {"OrderListHash", "3f6cce0fcc7b988ba378a357ede1af93"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateSPXWeeklyIndexOptionsAlgorithm.cs

@@ -105,7 +105,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public virtual long DataPoints => 65536;
+        public virtual long DataPoints => 57794;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -122,25 +122,26 @@ namespace QuantConnect.Algorithm.CSharp
             {"Average Loss", "-0.69%"},
             {"Compounding Annual Return", "58.005%"},
             {"Drawdown", "0.400%"},
-            {"Expectancy", "-1"},
+            {"Expectancy", "-0.5"},
             {"Net Profit", "0.588%"},
-            {"Sharpe Ratio", "1.448"},
+            {"Sharpe Ratio", "0.836"},
+            {"Sortino Ratio", "0"},
             {"Probabilistic Sharpe Ratio", "51.980%"},
-            {"Loss Rate", "100%"},
-            {"Win Rate", "0%"},
+            {"Loss Rate", "50%"},
+            {"Win Rate", "50%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "0.288"},
+            {"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.149"},
+            {"Treynor Ratio", "-0.086"},
             {"Total Fees", "$0.00"},
-            {"Estimated Strategy Capacity", "$8400000.00"},
+            {"Estimated Strategy Capacity", "$580000.00"},
             {"Lowest Capacity Asset", "SPXW 31K54PVWHUJHQ|SPX 31"},
             {"Portfolio Turnover", "0.48%"},
-            {"OrderListHash", "174bd0a99916d58ca3f12139306940db"}
+            {"OrderListHash", "07469a94a93198bbccadc8bc9cdfe87a"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateSPXWeeklyIndexOptionsStrategyAlgorithm.cs

@@ -48,7 +48,7 @@ namespace QuantConnect.Algorithm.CSharp
 
             // weekly option SPX contracts
             var spxw = AddIndexOption(spx, "SPXW");
-            spxw.SetFilter(u => u.Strikes(0, 1)
+            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());
@@ -66,7 +66,7 @@ namespace QuantConnect.Algorithm.CSharp
             OptionChain chain;
             if (slice.OptionChains.TryGetValue(_spxOption, out chain))
             {
-                // we find the first expiration group of call options and order them in ascending strike 
+                // 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)
@@ -109,7 +109,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public virtual long DataPoints => 35451;
+        public virtual long DataPoints => 40893;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -121,30 +121,31 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public virtual Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
-            {"Total Trades", "4"},
-            {"Average Win", "0.12%"},
-            {"Average Loss", "0.00%"},
-            {"Compounding Annual Return", "8.975%"},
+            {"Total Trades", "10"},
+            {"Average Win", "0.47%"},
+            {"Average Loss", "-0.01%"},
+            {"Compounding Annual Return", "99.729%"},
             {"Drawdown", "0.100%"},
-            {"Expectancy", "62.078"},
-            {"Net Profit", "0.110%"},
-            {"Sharpe Ratio", "-7.925"},
-            {"Probabilistic Sharpe Ratio", "1.216%"},
+            {"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", "125.16"},
-            {"Alpha", "-0.012"},
-            {"Beta", "0.001"},
-            {"Annual Standard Deviation", "0"},
+            {"Profit-Loss Ratio", "49.97"},
+            {"Alpha", "-1.975"},
+            {"Beta", "0.301"},
+            {"Annual Standard Deviation", "0.021"},
             {"Annual Variance", "0"},
-            {"Information Ratio", "-103.223"},
-            {"Tracking Error", "0.069"},
-            {"Treynor Ratio", "-2.449"},
+            {"Information Ratio", "-143.477"},
+            {"Tracking Error", "0.049"},
+            {"Treynor Ratio", "0.566"},
             {"Total Fees", "$0.00"},
-            {"Estimated Strategy Capacity", "$1800000.00"},
+            {"Estimated Strategy Capacity", "$13000000.00"},
             {"Lowest Capacity Asset", "SPXW XKX6S2GM9PGU|SPX 31"},
-            {"Portfolio Turnover", "0.03%"},
-            {"OrderListHash", "38db27781e4df93687d0895df9796c7d"}
+            {"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%"},
@@ -76,7 +77,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "₮220000.00"},
             {"Lowest Capacity Asset", "BTCUSDT 18N"},
             {"Portfolio Turnover", "22.80%"},
-            {"OrderListHash", "7417649395922ff3791471b4f3b5c021"}
+            {"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%"},
@@ -76,7 +77,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "₮12000000.00"},
             {"Lowest Capacity Asset", "BTCUSDT 18N"},
             {"Portfolio Turnover", "22.80%"},
-            {"OrderListHash", "7417649395922ff3791471b4f3b5c021"}
+            {"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%"},
@@ -75,7 +76,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$2000.00"},
             {"Lowest Capacity Asset", "BTCUSD E3"},
             {"Portfolio Turnover", "0.28%"},
-            {"OrderListHash", "7f892f0c42d8826ff770ee602fe207a2"}
+            {"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%"},
@@ -75,7 +76,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$640000.00"},
             {"Lowest Capacity Asset", "BTCUSD E3"},
             {"Portfolio Turnover", "0.28%"},
-            {"OrderListHash", "7f892f0c42d8826ff770ee602fe207a2"}
+            {"OrderListHash", "3c23bc8622691cb9d4cacb00de5b0dd8"}
         };
     }
 }

Algorithm.CSharp/BlackLittermanPortfolioOptimizationFrameworkAlgorithm.cs

@@ -88,30 +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"},
-            {"Portfolio Turnover", "64.52%"},
-            {"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", "fb30d137fffe2bc4195d261f0f195b69"}
+        };
+    }
+}

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/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,9 +159,9 @@ namespace QuantConnect.Algorithm.CSharp
             {"Treynor Ratio", "0"},
             {"Total Fees", "$0.00"},
             {"Estimated Strategy Capacity", "$370000.00"},
-            {"Lowest Capacity Asset", "ETHUSD XJ"},
+            {"Lowest Capacity Asset", "ETHUSD 2XR"},
             {"Portfolio Turnover", "104.59%"},
-            {"OrderListHash", "aea2e321d17414c1f3c6fa2491f10c88"}
+            {"OrderListHash", "bd538acb61fa1fd91732212664c9bbed"}
         };
     }
 }

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%"},
@@ -108,7 +109,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "€670000.00"},
             {"Lowest Capacity Asset", "DE30EUR 8I"},
             {"Portfolio Turnover", "1062.25%"},
-            {"OrderListHash", "64c098abe3c1e7206424b0c3825b0069"}
+            {"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,27 +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"},
             {"Portfolio Turnover", "7.91%"},
-            {"OrderListHash", "b2286d2421294408c3a390e614f40ef9"}
+            {"OrderListHash", "b9aded02d28fb04cfe7ecadc08cac6e9"}
         };
     }
 }

Algorithm.CSharp/CoarseFineAsyncUniverseRegressionAlgorithm.cs

@@ -0,0 +1,98 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
+using System;
+using System.Linq;
+using QuantConnect.Interfaces;
+using System.Collections.Generic;
+using QuantConnect.Data.Fundamental;
+using QuantConnect.Data.UniverseSelection;
+using QuantConnect.Algorithm.Framework.Selection;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Regression algorithm asserting that using separate coarse & fine selection with async universe settings is not allowed
+    /// </summary>
+    public class CoarseFineAsyncUniverseRegressionAlgorithm : 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(2013, 10, 07);
+            SetEndDate(2013, 10, 11);
+
+            UniverseSettings.Asynchronous = true;
+
+            var threwException = false;
+            try
+            {
+                AddUniverse(CoarseSelectionFunction, FineSelectionFunction);
+            }
+            catch (ArgumentException)
+            {
+                threwException = true;
+                // expected
+            }
+
+            if (!threwException)
+            {
+                throw new Exception("Expected exception to be thrown for AddUniverse");
+            }
+
+            SetUniverseSelection(new FineFundamentalUniverseSelectionModel(CoarseSelectionFunction, FineSelectionFunction));
+        }
+
+        private IEnumerable<Symbol> CoarseSelectionFunction(IEnumerable<CoarseFundamental> coarse)
+        {
+            return Enumerable.Empty<Symbol>();
+        }
+
+        private IEnumerable<Symbol> FineSelectionFunction(IEnumerable<FineFundamental> fine)
+        {
+            return Enumerable.Empty<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 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>
+        {
+            {"OrderListHash", "d41d8cd98f00b204e9800998ecf8427e"}
+        };
+    }
+}

Algorithm.CSharp/CoarseFineFundamentalRegressionAlgorithm.cs

@@ -106,7 +106,7 @@ namespace QuantConnect.Algorithm.CSharp
             // we want 50% allocation in each security in our universe
             foreach (var security in _changes.AddedSecurities)
             {
-                if (security.Fundamentals.EarningRatios.EquityPerShareGrowth.OneYear > 0.25m)
+                if (security.Fundamentals.EarningRatios.EquityPerShareGrowth.OneYear > 0.25)
                 {
                     SetHoldings(security.Symbol, 0.5m);
                     Debug("Purchased Stock: " + security.Symbol.Value);
@@ -159,7 +159,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 7239;
+        public long DataPoints => 7244;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -178,23 +178,24 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "1.400%"},
             {"Expectancy", "0"},
             {"Net Profit", "1.163%"},
-            {"Sharpe Ratio", "2.754"},
+            {"Sharpe Ratio", "2.666"},
+            {"Sortino Ratio", "19.179"},
             {"Probabilistic Sharpe Ratio", "64.748%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "100%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "0.277"},
+            {"Alpha", "0.272"},
             {"Beta", "0.436"},
             {"Annual Standard Deviation", "0.086"},
             {"Annual Variance", "0.007"},
             {"Information Ratio", "3.572"},
             {"Tracking Error", "0.092"},
-            {"Treynor Ratio", "0.54"},
+            {"Treynor Ratio", "0.523"},
             {"Total Fees", "$2.00"},
             {"Estimated Strategy Capacity", "$49000000.00"},
             {"Lowest Capacity Asset", "IBM R735QTJ8XC9X"},
             {"Portfolio Turnover", "6.64%"},
-            {"OrderListHash", "159887a90516df8ba8e8d35b9c30b227"}
+            {"OrderListHash", "547783661a29f4cc71800be8f5ed4fc2"}
         };
     }
 }

Algorithm.CSharp/CoarseFineOptionUniverseChainRegressionAlgorithm.cs

@@ -35,6 +35,12 @@ namespace QuantConnect.Algorithm.CSharp
         private Symbol _aapl;
         private Symbol _twx;
 
+        private Dictionary<string, decimal> _rawPrices = new()
+        {
+            { "AOL", 70  },
+            { "AAPL", 650 }
+        };
+
         public override void Initialize()
         {
             _twx = QuantConnect.Symbol.Create("TWX", SecurityType.Equity, Market.USA);
@@ -106,6 +112,15 @@ namespace QuantConnect.Algorithm.CSharp
                 {
                     throw new Exception($"Was expecting DataNormalizationMode.Raw configurations for {security.Symbol}");
                 }
+
+                if (security.Symbol.SecurityType == SecurityType.Equity)
+                {
+                    var expectedPrice = _rawPrices[security.Symbol.ID.Symbol];
+                    if (Math.Abs(security.Price - expectedPrice) > expectedPrice * 0.1m)
+                    {
+                        throw new Exception($"Unexpected raw prices for symbol {security.Symbol}");
+                    }
+                }
             }
             _changes = SecurityChanges.None;
         }
@@ -142,7 +157,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 998462;
+        public long DataPoints => 998464;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -154,7 +169,31 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
-            {"OrderListHash", "2a6319d0d474f976e653dd1ebc42caac"}
+            {"Total Trades", "13"},
+            {"Average Win", "0.04%"},
+            {"Average Loss", "-0.05%"},
+            {"Compounding Annual Return", "-24.719%"},
+            {"Drawdown", "0.500%"},
+            {"Expectancy", "-0.685"},
+            {"Net Profit", "-0.233%"},
+            {"Sharpe Ratio", "-9.078"},
+            {"Sortino Ratio", "0"},
+            {"Probabilistic Sharpe Ratio", "0%"},
+            {"Loss Rate", "83%"},
+            {"Win Rate", "17%"},
+            {"Profit-Loss Ratio", "0.89"},
+            {"Alpha", "4.632"},
+            {"Beta", "-1.524"},
+            {"Annual Standard Deviation", "0.029"},
+            {"Annual Variance", "0.001"},
+            {"Information Ratio", "-72.647"},
+            {"Tracking Error", "0.048"},
+            {"Treynor Ratio", "0.172"},
+            {"Total Fees", "$16.10"},
+            {"Estimated Strategy Capacity", "$3100000.00"},
+            {"Lowest Capacity Asset", "AOL VRKS95ENLBYE|AOL R735QTJ8XC9X"},
+            {"Portfolio Turnover", "17.64%"},
+            {"OrderListHash", "c2d13c2884c47af9274ecab0d0299c1f"}
         };
     }
 }

Algorithm.CSharp/CoarseFundamentalTop3Algorithm.cs

@@ -133,23 +133,24 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "1.700%"},
             {"Expectancy", "0.850"},
             {"Net Profit", "0.637%"},
-            {"Sharpe Ratio", "1.088"},
+            {"Sharpe Ratio", "1.024"},
+            {"Sortino Ratio", "2.169"},
             {"Probabilistic Sharpe Ratio", "50.223%"},
             {"Loss Rate", "40%"},
             {"Win Rate", "60%"},
             {"Profit-Loss Ratio", "2.08"},
-            {"Alpha", "0.198"},
+            {"Alpha", "0.196"},
             {"Beta", "0.741"},
             {"Annual Standard Deviation", "0.118"},
             {"Annual Variance", "0.014"},
             {"Information Ratio", "2.294"},
             {"Tracking Error", "0.097"},
-            {"Treynor Ratio", "0.173"},
+            {"Treynor Ratio", "0.163"},
             {"Total Fees", "$27.94"},
             {"Estimated Strategy Capacity", "$200000000.00"},
             {"Lowest Capacity Asset", "AAPL R735QTJ8XC9X"},
             {"Portfolio Turnover", "26.69%"},
-            {"OrderListHash", "de456413f89396bd6f920686219ed0a5"}
+            {"OrderListHash", "0baae584118ecbce79dcf0cb001d5852"}
         };
     }
 }

Algorithm.CSharp/CoarseNoLookAheadBiasAlgorithm.cs

@@ -112,6 +112,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%"},

Algorithm.CSharp/CoarseSelectionTimeRegressionAlgorithm.cs

@@ -117,7 +117,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "1.000%"},
             {"Expectancy", "0"},
             {"Net Profit", "1.003%"},
-            {"Sharpe Ratio", "5.36"},
+            {"Sharpe Ratio", "5.273"},
+            {"Sortino Ratio", "7.973"},
             {"Probabilistic Sharpe Ratio", "69.521%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
@@ -128,12 +129,12 @@ namespace QuantConnect.Algorithm.CSharp
             {"Annual Variance", "0.007"},
             {"Information Ratio", "6.477"},
             {"Tracking Error", "0"},
-            {"Treynor Ratio", "0.462"},
+            {"Treynor Ratio", "0.455"},
             {"Total Fees", "$3.08"},
             {"Estimated Strategy Capacity", "$720000000.00"},
             {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
             {"Portfolio Turnover", "12.54%"},
-            {"OrderListHash", "50145c3c1d58b09f38ec1b77cfe69eae"}
+            {"OrderListHash", "ac9d803b06341e870fd6875cc26686af"}
         };
     }
 }

Algorithm.CSharp/Collective2PortfolioSignalExportDemonstrationAlgorithm.cs

@@ -0,0 +1,188 @@
+/*
+ * 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.Algorithm.Framework.Portfolio.SignalExports;
+using QuantConnect.Data;
+using QuantConnect.Indicators;
+using QuantConnect.Interfaces;
+using System.Collections.Generic;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// This algorithm sends a list of portfolio targets from algorithm's Portfolio 
+    /// to Collective2 API every time the ema indicators crosses between themselves
+    /// </summary>
+    /// <meta name="tag" content="using data" />
+    /// <meta name="tag" content="using quantconnect" />
+    /// <meta name="tag" content="securities and portfolio" />
+    public class Collective2PortfolioSignalExportDemonstrationAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        /// <summary>
+        /// Collective2 APIv4 KEY: This value is provided by Collective2 in their webpage in your account section (See https://collective2.com/account-info)
+        /// See API documentation at https://trade.collective2.com/c2-api
+        /// </summary>
+        private const string _collective2ApiKey = "YOUR APIV4 KEY";
+
+        /// <summary>
+        /// Collective2 System ID: This value is found beside the system's name (strategy's name) on the main system page
+        /// </summary>
+        private const int _collective2SystemId = 0;
+
+        private ExponentialMovingAverage _fast;
+        private ExponentialMovingAverage _slow;
+        private bool _emaFastWasAbove;
+        private bool _emaFastIsNotSet;
+        private bool _firstCall = true;
+
+        /// <summary>
+        /// Symbols accepted by Collective2. Collective2 accepts stock,
+        /// future, forex and US stock option symbols 
+        /// </summary>
+        private List<Symbol> _symbols = new()
+        {   
+            QuantConnect.Symbol.Create("SPY", SecurityType.Equity, Market.USA, null, null),
+            QuantConnect.Symbol.Create("EURUSD", SecurityType.Forex, Market.Oanda, null, null),
+            QuantConnect.Symbol.CreateFuture("ES", Market.CME, new DateTime(2023, 12, 15), null),
+            QuantConnect.Symbol.CreateOption("GOOG", Market.USA, OptionStyle.American, OptionRight.Call, 130, new DateTime(2023, 9, 1)),
+        };
+
+        /// <summary>
+        /// Initialize the date and add all equity symbols present in _symbols list
+        /// </summary>
+        public override void Initialize()
+        {
+            SetStartDate(2013, 10, 07);
+            SetEndDate(2013, 10, 11);
+            SetCash(100 * 1000);
+
+            foreach (var item in _symbols)
+            {
+                AddSecurity(item);
+            }
+
+            _fast = EMA("SPY", 10);
+            _slow = EMA("SPY", 100);
+
+            // Initialize this flag, to check when the ema indicators crosses between themselves
+            _emaFastIsNotSet = true;
+
+            // Set Collective2 signal export provider
+            SignalExport.AddSignalExportProviders(new Collective2SignalExport(_collective2ApiKey, _collective2SystemId));
+
+            SetWarmUp(100);
+        }
+
+        /// <summary>
+        /// Reduce the quantity of holdings for SPY or increase it, depending the case, 
+        /// when the EMA's indicators crosses between themselves, then send a signal to 
+        /// Collective2 API
+        /// </summary>
+        /// <param name="slice"></param>
+        public override void OnData(Slice slice)
+        {
+            if (IsWarmingUp) return;
+
+            // Place an order as soon as possible to send a signal.
+            if (_firstCall)
+            {
+                SetHoldings("SPY", 0.1);
+                SignalExport.SetTargetPortfolioFromPortfolio();
+                _firstCall = false;
+            }
+
+            // Set the value of flag _emaFastWasAbove, to know when the ema indicators crosses between themselves
+            if (_emaFastIsNotSet)
+            {
+                if (_fast > _slow * 1.001m)
+                {
+                    _emaFastWasAbove = true;
+                }
+                else
+                {
+                    _emaFastWasAbove = false;
+                }
+                _emaFastIsNotSet = false;
+            }
+
+            // Check whether ema fast and ema slow crosses. If they do, set holdings to SPY
+            // or reduce its holdings, and send signals to the Collective2 API from your
+            // Portfolio
+            if ((_fast > _slow * 1.001m) && (!_emaFastWasAbove))
+            {
+                SetHoldings("SPY", 0.1);
+                SignalExport.SetTargetPortfolioFromPortfolio();
+            }
+            else if ((_fast < _slow * 0.999m) && (_emaFastWasAbove))
+            {
+                SetHoldings("SPY", 0.01);
+                SignalExport.SetTargetPortfolioFromPortfolio();
+            }
+        }
+
+        /// <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 long DataPoints => 4155;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public int AlgorithmHistoryDataPoints => 11147;
+
+        /// <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", "14.180%"},
+            {"Drawdown", "0.200%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "0.170%"},
+            {"Sharpe Ratio", "4.88"},
+            {"Sortino Ratio", "0"},
+            {"Probabilistic Sharpe Ratio", "67.725%"},
+            {"Loss Rate", "0%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "-0.088"},
+            {"Beta", "0.099"},
+            {"Annual Standard Deviation", "0.022"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "-9.315"},
+            {"Tracking Error", "0.201"},
+            {"Treynor Ratio", "1.086"},
+            {"Total Fees", "$2.00"},
+            {"Estimated Strategy Capacity", "$260000000.00"},
+            {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
+            {"Portfolio Turnover", "2.00%"},
+            {"OrderListHash", "e79432ec624fbed8497b0171b33bfbe2"}
+        };
+    }
+}