Shuffle init load

.devcontainer/Dockerfile

@@ -1,8 +0,0 @@
-# Use QuantConnect Research as the base
-FROM quantconnect/research:latest
-
-# Install dos2unix utility for converting pesky windows formatting when needed
-RUN apt-get update && apt-get install -y dos2unix
-
-# Install QuantConnect Stubs for Python Autocomplete
-RUN pip install --no-cache-dir quantconnect-stubs

.devcontainer/devcontainer.json

@@ -1,34 +0,0 @@
-{
-	"name": "Lean Development Container",
-
-	"workspaceMount": "source=${localWorkspaceFolder},target=/Lean,type=bind",
-	"workspaceFolder": "/Lean",
-
-	// Use devcontainer Dockerfile that is based on Lean foundation image
-	"build": { "dockerfile": "Dockerfile" },
-	
-	// Set *default* container specific settings.json values on container create.
-	"settings": { 
-		"terminal.integrated.profiles.linux": {
-			"bash": {
-				"path": "bash",
-				"icon": "terminal-bash"
-			}
-		}
-	},
-
-	// Add the IDs of extensions you want installed when the container is created.
-	"extensions": ["ms-dotnettools.csharp", "ms-python.python", "ms-python.vscode-pylance", "formulahendry.dotnet-test-explorer", "eamodio.gitlens", "yzhang.markdown-all-in-one"],
-
-	// Use 'forwardPorts' to make a list of ports inside the container available locally.
-	// "forwardPorts": [],
-
-	// Uncomment the next line to run commands after the container is created - for example installing curl.
-	"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": [ 
-		// Example data mount from local machine, must use target directory in Config.json
-		// "source=C:/Users/XXXXXXXXXXXX/Lean/Data,target=/Data,type=bind,consistency=cached" 
-	]
-}

.dockerignore

@@ -1,6 +1,4 @@
-packages/*
-.git/*
-.github/*
-.vs/*
-.nuget/*
-Tests/*
+*/packages/*
+*/.git/*
+*/.vs/*
+*/.nuget/*

.editorconfig

@@ -1,13 +0,0 @@
-root = true
-
-[*]
-charset = utf-8
-indent_size = 4
-indent_style = space
-insert_final_newline = true
-
-[*.{js,yml,json,config,csproj}]
-indent_size = 2
-
-[*.sh]
-end_of_line = lf

.github/funding.yml

@@ -1,4 +0,0 @@
-# These are supported funding model platforms
-
-github: quantconnect
-#custom: ['https://github.com/sponsors/QuantConnect']

.github/pull_request_template.md

@@ -24,8 +24,6 @@
 #### Types of changes
 <!--- What types of changes does your code introduce? Put an `x` in all the boxes that apply: -->
 - [ ] Bug fix (non-breaking change which fixes an issue)
-- [ ] Refactor (non-breaking change which improves implementation)
-- [ ] Performance (non-breaking change which improves performance. Please add associated performance test and results)
 - [ ] New feature (non-breaking change which adds functionality)
 - [ ] Breaking change (fix or feature that would cause existing functionality to change)
 - [ ] Non-functional change (xml comments/documentation/etc)
@@ -39,4 +37,4 @@
 - [ ] All new and existing tests passed.
 - [ ] My branch follows the naming convention `bug-<issue#>-<description>` or `feature-<issue#>-<description>`
 
-<!--- Template inspired by https://www.talater.com/open-source-templates/#/page/99 -->
+<!--- Template inspired by https://www.talater.com/open-source-templates/#/page/99 -->

.github/workflows/api-tests.yml

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

.github/workflows/benchmarks.yml

@@ -1,39 +0,0 @@
-name: Benchmarks
-
-on:
-  push:
-    branches: ['*']
-    tags: ['*']
-  pull_request:
-    branches: [master]
-
-jobs:
-  build:
-    runs-on: self-hosted
-    container:
-        image: quantconnect/lean:foundation
-        volumes:
-          - /nas:/Data
-    steps:
-      - uses: actions/checkout@v2
-
-      - name: Checkout Lean Master
-        uses: actions/checkout@v2
-        with:
-          repository: QuantConnect/Lean
-          path: LeanMaster
-          ref: 'master'
-      - name: Build Lean Master
-        run: dotnet build --verbosity q /p:Configuration=Release /p:WarningLevel=1 LeanMaster/QuantConnect.Lean.sln
-
-      - name: Run Benchmarks Master
-        run: cp run_benchmarks.py LeanMaster/run_benchmarks.py && cd LeanMaster && python run_benchmarks.py /Data && cd ../
-
-      - name: Build
-        run: dotnet build --verbosity q /p:Configuration=Release /p:WarningLevel=1 QuantConnect.Lean.sln
-
-      - name: Run Benchmarks
-        run: python run_benchmarks.py /Data
-
-      - name: Compare Benchmarks
-        run: python compare_benchmarks.py LeanMaster/benchmark_results.json benchmark_results.json

.github/workflows/gh-actions.yml

@@ -1,30 +0,0 @@
-name: Build & Test Lean
-
-on:
-  push:
-    branches: ['*']
-    tags: ['*']
-  pull_request:
-    branches: [master]
-
-jobs:
-  build:
-    runs-on: ubuntu-20.04
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v2
-      - name: Free space
-        run: df -h && rm -rf /usr/share/dotnet && sudo rm -rf /usr/local/lib/android && sudo rm -rf /opt/ghc && rm -rf /opt/hostedtoolcache* && df -h
-
-      - 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/rebase-org-branches.yml

@@ -1,21 +0,0 @@
-name: Rebase Organization Branches
-
-on:
-  push:
-    branches:
-      - 'master'
-
-jobs:
-  build:
-    runs-on: ubuntu-20.04
-    steps:
-      - uses: actions/checkout@v2
-        with:
-          fetch-depth: 0
-
-      - name: Rebase Organization Branches
-        run: |
-          chmod +x rebase_organization_branches.sh
-          ./rebase_organization_branches.sh
-        env:
-          QC_GIT_TOKEN: ${{ secrets.QC_GIT_TOKEN }}

.github/workflows/regression-tests.yml

@@ -1,28 +0,0 @@
-name: Regression Tests
-
-on:
-  push:
-    branches: ['*']
-    tags: ['*']
-  pull_request:
-    branches: [master]
-
-jobs:
-  build:
-    runs-on: ubuntu-20.04
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v2
-      - name: Free space
-        run: df -h && rm -rf /usr/share/dotnet && sudo rm -rf /usr/local/lib/android && sudo rm -rf /opt/ghc && rm -rf /opt/hostedtoolcache* && df -h
-
-      - 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/report-generator.yml

@@ -1,30 +0,0 @@
-name: Report Generator Tests
-
-on:
-  push:
-    branches: ['*']
-    tags: ['*']
-  pull_request:
-    branches: [master]
-
-jobs:
-  build:
-    runs-on: ubuntu-20.04
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v2
-      - name: Free space
-        run: df -h && rm -rf /usr/share/dotnet && sudo rm -rf /usr/local/lib/android && sudo rm -rf /opt/ghc && rm -rf /opt/hostedtoolcache* && df -h
-
-      - 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 Backtest
-            cd ./Launcher/bin/Release && dotnet QuantConnect.Lean.Launcher.dll && cd ../../../
-            # Run Report
-            cd ./Report/bin/Release && dotnet ./QuantConnect.Report.dll --backtest-data-source-file ../../../Launcher/bin/Release/BasicTemplateFrameworkAlgorithm.json --close-automatically true

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

@@ -1,36 +0,0 @@
-name: Research Regression Tests
-
-on:
-  push:
-    branches: ['*']
-    tags: ['*']
-  pull_request:
-    branches: [master]
-
-jobs:
-  build:
-    runs-on: ubuntu-20.04
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v2
-      - name: Free space
-        run: df -h && rm -rf /usr/share/dotnet && sudo rm -rf /usr/local/lib/android && sudo rm -rf /opt/ghc && rm -rf /opt/hostedtoolcache* && df -h
-
-      - 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

@@ -1,57 +0,0 @@
-name: Python Virtual Environments
-
-on:
-  push:
-    branches: ['*']
-    tags: ['*']
-  pull_request:
-    branches: [master]
-
-jobs:
-  build:
-    runs-on: ubuntu-20.04
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v2
-      - name: Free space
-        run: df -h && rm -rf /usr/share/dotnet && sudo rm -rf /usr/local/lib/android && sudo rm -rf /opt/ghc && rm -rf /opt/hostedtoolcache* && df -h
-
-      - 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.185 && 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.185 && 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 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 Transformers
-            dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests.Transformers" --blame-hang-timeout 120seconds --blame-crash && \
-            dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests.XTransformers" --blame-hang-timeout 120seconds --blame-crash && \
-            # Run Shap
-            dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests.ShapTest" --blame-hang-timeout 120seconds --blame-crash

.gitignore

@@ -1,6 +1,3 @@
-# OS Files
-.DS_Store
-
 # Object files
 *.o
 *.ko
@@ -37,9 +34,6 @@
 
 # QC Cloud Setup Bash Files
 *.sh
-# Include docker launch scripts for Mac/Linux
-!run_docker.sh
-!research/run_docker_notebook.sh
 
 # QC Config Files:
 # config.json
@@ -147,7 +141,6 @@ $tf/
 # ReSharper is a .NET coding add-in
 _ReSharper*/
 *.[Rr]e[Ss]harper
-*.DotSettings
 *.DotSettings.user
 
 # JustCode is a .NET coding addin-in
@@ -173,9 +166,6 @@ AutoTest.Net/
 # Installshield output folder
 [Ee]xpress/
 
-# JetBrains Rider
-.idea/
-
 # DocProject is a documentation generator add-in
 DocProject/buildhelp/
 DocProject/Help/*.HxT
@@ -199,7 +189,6 @@ publish/
 
 # NuGet Packages
 *.nupkg
-!LocalPackages/*
 # The packages folder can be ignored because of Package Restore
 **/packages/*
 # except build/, which is used as an MSBuild target.
@@ -208,7 +197,6 @@ publish/
 #!**/packages/repositories.config
 # ignore sln level nuget
 .nuget/
-!.nuget/NuGet.config
 
 # Windows Azure Build Output
 csx/
@@ -274,9 +262,3 @@ Launcher/Plugins/*
 /ApiPython/quantconnect.egg-info/*
 
 QuantConnect.Lean.sln.DotSettings*
-
-#User notebook files
-Research/Notebooks
-
-#Docker result files
-Results/

.nuget/NuGet.config

@@ -1,10 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<configuration>
-    <packageRestore>
-        <add key="enabled" value="true" />
-        <add key="automatic" value="true" />
-    </packageRestore>
-    <packageSources>
-        <add key="LocalPackages" value="../LocalPackages" />
-    </packageSources>
-</configuration>

.travis.yml

@@ -1,23 +1,21 @@
+sudo: required
 language: csharp
-mono: none
-dotnet: 5.0
-os: linux
-dist: focal
+mono:
+  - 5.8.0
+solution: QuantConnect.Lean.sln
 before_install:
   - export PATH="$HOME/miniconda3/bin:$PATH"
-  - export PYTHONNET_PYDLL="$HOME/miniconda3/lib/libpython3.6m.so"
-  - wget -q https://cdn.quantconnect.com/miniconda/Miniconda3-4.5.12-Linux-x86_64.sh
-  - bash Miniconda3-4.5.12-Linux-x86_64.sh -b
-  - rm -rf Miniconda3-4.5.12-Linux-x86_64.sh
+  - wget https://cdn.quantconnect.com/miniconda/Miniconda3-4.3.31-Linux-x86_64.sh
+  - bash Miniconda3-4.3.31-Linux-x86_64.sh -b
+  - rm -rf Miniconda3-4.3.31-Linux-x86_64.sh
   - sudo ln -s $HOME/miniconda3/lib/libpython3.6m.so /usr/lib/libpython3.6m.so
   - conda update -y python conda pip
-  - conda install -y python=3.6.8
-  - conda install -y numpy=1.18.1
-  - conda install -y pandas=0.25.3
-  - conda install -y cython=0.29.15
-  - conda install -y scipy=1.4.1
-  - conda install -y wrapt=1.12.1
+  - conda install -y cython pandas scipy
+install:
+  - nuget restore QuantConnect.Lean.sln
+  - nuget install NUnit.Runners -Version 2.6.4 -OutputDirectory testrunner
 script:
-  - dotnet nuget add source $TRAVIS_BUILD_DIR/LocalPackages
-  - dotnet build /p:Configuration=Release /v:quiet /p:WarningLevel=1 QuantConnect.Lean.sln
-  - dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter TestCategory!=TravisExclude -- TestRunParameters.Parameter\(name=\"log-handler\", value=\"ConsoleErrorLogHandler\"\)
+  - msbuild /p:Configuration=Release /p:VbcToolExe=vbnc.exe QuantConnect.Lean.sln
+  - mono ./testrunner/NUnit.Runners.2.6.4/tools/nunit-console.exe ./Tests/bin/Release/QuantConnect.Tests.dll --exclude:TravisExclude --labels
+after_success:
+  - coveralls

.vs/readme.md

@@ -1,73 +0,0 @@
-<h1>Local Development with Visual Studio</h1>
-
-This document contains information regarding ways to use Visual Studio to work with the Lean engine, this includes a couple options that make lean easy to develop on any machine:
-
-- Using Lean CLI -> A great tool for working with your algorithms locally, while still being able to deploy to the cloud and have access to Lean data. It is also able to run algorithms locally through our official docker images **Recommended for algorithm development.
-
-- Locally installing all dependencies to run Lean with Visual Studio on your OS.
-
-<br />
-
-<h1>Setup</h1>
-
-<h2>Option 1: Lean CLI</h2>
-
-To use Lean CLI follow the instructions for installation and tutorial for usage in our [documentation](https://www.quantconnect.com/docs/v2/lean-cli/getting-started/lean-cli).
-
-<br />
-
-<h2>Option 2: Install Locally</h2>
-
-1. Install [.Net 6](https://dotnet.microsoft.com/download) for the project
-
-2. (Optional) Get [Python 3.8.13](https://www.python.org/downloads/release/python-3813/) for running Python algorithms
-    - Follow Python instructions [here](https://github.com/QuantConnect/Lean/tree/master/Algorithm.Python#installing-python-38) for your platform
-
-3. Get [Visual Studio](https://visualstudio.microsoft.com/vs/)
-
-4. Get Lean into VS
-    - Download the repo or clone it using: _git clone [https://github.com/QuantConnect/Lean](https://github.com/QuantConnect/Lean)_
-    - Open the project file with VS (QuantConnect.Lean.sln)
-
-Your environment is prepared and ready to run lean
-
-<br />
-
-<h1>How to use Lean</h1>
-
-This section will cover configuring, launching and debugging lean. This is only applicable to option 2 from above. This does not apply to Lean CLI, please refer to [CLI documentation](https://www.quantconnect.com/docs/v2/lean-cli/getting-started/lean-cli)
-
-<br />
-
-<h2>Configuration</h2>
-
-We need to be sure that our Lean configuration at **.\Launcher\config.json** is properly set.
-
-Your configuration file should look something like this for the following languages:
-
-<h3>Python:</h3>
-
-    "algorithm-type-name": "**AlgorithmName**",
-
-    "algorithm-language": "Python",
-
-    "algorithm-location": "../../../Algorithm.Python/**AlgorithmName**.py",
-
-<h3>C#:</h3>
-
-    "algorithm-type-name": "**AlgorithmName**",
-
-    "algorithm-language": "CSharp",
-
-    "algorithm-location": "QuantConnect.Algorithm.CSharp.dll",
-
-<br />
-
-<h2>Launching Lean</h2>
-
-Now that lean is configured we can launch. Use Visual Studio's run option, Make sure QuantConnect.Lean.Launcher is selected as the launch project. Any breakpoints in Lean C# will be triggered.
-
-<br />
-
-<h1>Common Issues</h1>
-Here we will cover some common issues with setting this up. Feel free to contribute to this section!

.vscode/launch.json

@@ -1,47 +0,0 @@
-{
-    /*
-        VS Code Launch configurations for the LEAN engine
-
-        Launch:
-        Builds the project with dotnet 6 and then launches the program using coreclr; supports debugging.
-        In order to use this you need dotnet 6 on your system path, As well as the C# extension from the 
-        marketplace.
-
-        Attach to Python:
-        Will attempt to attach to LEAN running locally using DebugPy. Requires that the process is
-        actively running and config is set: "debugging": true, "debugging-method": "DebugPy",
-        Requires Python extension from the marketplace. Currently only works with algorithms in
-        Algorithm.Python directory. This is because we map that directory to our build directory
-        that contains the py file at runtime. If using another location change "localRoot" value 
-        to the directory in use.
-    */
-
-    "version": "0.2.0",
-    "configurations": [
-        {
-            "name": "Launch",
-            "type": "coreclr",
-            "request": "launch",
-            "preLaunchTask": "build",
-            "program": "${workspaceFolder}/Launcher/bin/Debug/QuantConnect.Lean.Launcher.dll",
-            "args": [
-                "--config",
-                "${workspaceFolder}/Launcher/bin/Debug/config.json"
-            ],
-            "cwd": "${workspaceFolder}/Launcher/bin/Debug/",
-            "stopAtEntry": false,
-            "console": "integratedTerminal",
-            "internalConsoleOptions": "neverOpen"
-        },
-        {
-            "name": "Attach to Python",
-            "type": "python",
-            "request": "attach",
-            "port": 5678,
-            "pathMappings":[{ 
-                "localRoot": "${workspaceFolder}", 
-                "remoteRoot": "${workspaceFolder}"
-            }]
-        }
-    ]
-}

.vscode/launch_research.sh

@@ -1,15 +0,0 @@
-# Realpath polyfill, notably absent macOS and some debian distros
-absolute_path() {
-  echo "$(cd "$(dirname "${1}")" && pwd)/$(basename "${1}")"
-}
-
-# Get build directory from args position 1, or use default
-DEFAULT_BUILD_DIR=../Launcher/bin/Debug/
-BUILD_DIR=${1:-$DEFAULT_BUILD_DIR}
-BUILD_DIR=$(absolute_path "${BUILD_DIR}")
-
-#Add our build directory to python path for python kernel
-export PYTHONPATH="${PYTHONPATH}:${BUILD_DIR}"
-
-# Launch jupyter-lab
-jupyter-lab --allow-root --no-browser --notebook-dir=$BUILD_DIR --LabApp.token=''

.vscode/readme.md

@@ -1,160 +0,0 @@
-<h1>Local Development & Docker Integration with Visual Studio Code</h1>
-
-This document contains information regarding ways to use Visual Studio Code to work with the Lean engine, this includes a couple options that make lean easy to develop on any machine:
-
-- Using Lean CLI -> A great tool for working with your algorithms locally, while still being able to deploy to the cloud and have access to Lean data. It is also able to run algorithms locally through our official docker images **Recommended for algorithm development.
-
-- Using a Lean Dev container -> A docker environment with all dependencies pre-installed to allow seamless Lean development across platforms. Great for open source contributors.
-
-- Locally installing all dependencies to run Lean with Visual Studio Code on your OS.
-
-<br />
-
-<h1>Setup</h1>
-
-<h2>Option 1: Lean CLI</h2>
-
-To use Lean CLI follow the instructions for installation and tutorial for usage in our [documentation](https://www.quantconnect.com/docs/v2/lean-cli/key-concepts/getting-started)
-
-<br />
-
-<h2>Option 2: Lean Development Container</h2>
-
-Before anything we need to ensure a few things have been done for either option:
-
-1. Get [Visual Studio Code](https://code.visualstudio.com/download)
-    - Get [Remote Containers](https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.remote-containers) Extension
-
-2. Get [Docker](https://docs.docker.com/get-docker/):
-    - Follow the instructions for your Operating System
-    - New to Docker? Try [docker getting-started](https://docs.docker.com/get-started/)
-
-3. Pull Lean’s latest research image from a terminal
-    - `docker pull quantconnect/research:latest`
-
-4. Get Lean into VS Code
-    - Download the repo or clone it using: `git clone [https://github.com/QuantConnect/Lean](https://github.com/QuantConnect/Lean)`
-    - Open the folder using VS Code
-
-5. Open Development Container
-    - In VS Code, either:
-        - Select "Reopen in Container" from pop up box.
-
-            OR
-
-        - Ctrl+Shift+P (Command Palette) and select "Remote-Containers: Rebuild and Reopen in Container"
-
-You should now be in the development container, give VS Code a moment to prepare and you will be ready to go!
-If you would like to mount any additional local files to your container, checkout [devcontainer.json "mounts" section](https://containers.dev/implementors/json_reference/) for an example! Upon any mount changes you must rebuild the container using Command Palette as in step 5.
-
-<br />
-
-<h2>Option 3: Install Dependencies Locally</h2>
-
-1. Install [.NET 6](https://dotnet.microsoft.com/en-us/download/dotnet/6.0) for the project
-
-2. (Optional) Get [Python 3.8.13](https://www.python.org/downloads/release/python-3813/) for running Python algorithms
-    - Follow Python instructions [here](https://github.com/QuantConnect/Lean/tree/master/Algorithm.Python#installing-python-38) for your platform
-
-3. Get [Visual Studio Code](https://code.visualstudio.com/download)
-    - Get the Extension [C#](https://marketplace.visualstudio.com/items?itemName=ms-dotnettools.csharp) for C# Debugging
-    - Get the Extension [Python](https://marketplace.visualstudio.com/items?itemName=ms-python.python) for Python Debugging
-
-4. Get Lean into VS Code
-    - Download the repo or clone it using: `git clone [https://github.com/QuantConnect/Lean](https://github.com/QuantConnect/Lean)`
-    - Open the folder using VS Code
-
-Your environment is prepared and ready to run Lean.
-
-<br />
-
-<h1>How to use Lean</h1>
-
-This section will cover configuring, building, launching and debugging lean. This is only applicable to option 2 from above. This does not apply to Lean CLI, please refer to [CLI documentation](https://www.quantconnect.com/docs/v2/lean-cli/key-concepts/getting-started)
-
-<br />
-
-<h2>Configuration</h2>
-
-We need to be sure that our Lean configuration at **.\Launcher\config.json** is properly set.
-
-Your configuration file should look something like this for the following languages:
-
-<h3>Python:</h3>
-
-    "algorithm-type-name": "**AlgorithmName**",
-
-    "algorithm-language": "Python",
-
-    "algorithm-location": "../../../Algorithm.Python/**AlgorithmName**.py",
-
-<h3>C#:</h3>
-
-    "algorithm-type-name": "**AlgorithmName**",
-
-    "algorithm-language": "CSharp",
-
-    "algorithm-location": "QuantConnect.Algorithm.CSharp.dll",
-
-<br />
-
-<h2>Building</h2>
-
-Before running Lean, we must build the project. Currently the VS Code task will automatically build before launching. But find more information below about how to trigger building manually.
-
-In VS Code run build task (Ctrl+Shift+B or "Terminal" dropdown); there are a few options:
-
-- __Build__ - basic build task, just builds Lean once
-- __Rebuild__ - rebuild task, completely rebuilds the project. Use if having issues with debugging symbols being loaded for your algorithms.
-- __Clean__ - deletes out all project build files
-
-<br />
-
-<h2>Launching Lean</h2>
-
-Now that lean is configured and built we can launch Lean. Under "Run & Debug" use the launch option "Launch". This will start Lean with C# debugging. Any breakpoints in Lean C# will be triggered.
-
-<br />
-
-<h2>Debugging Python</h2>
-
-Python algorithms require a little extra work in order to be able to debug them. Follow the steps below to get Python debugging working.
-
-<br />
-
-<h3>Modifying the Configuration</h3>
-
-First in order to debug a Python algorithm in VS Code we must make the following change to our configuration (Launcher\config.json) under the comment debugging configuration:
-
-    "debugging": true,
-    "debugging-method": "DebugPy",
-
-In setting this we are telling Lean to expect a debugger connection using ‘Python Tools for Visual Studio Debugger’. Once this is set Lean will stop upon initialization and await a connection to the debugger via port 5678.
-
-<br />
-
-<h3>Using VS Code Launch Options to Connect</h3>
-
-Now that Lean is configured for the python debugger we can make use of the programmed launch options to connect to Lean during runtime.
-
-Start Lean using the "Launch" option covered above. Once Lean starts you should see the messages in figure 2 If the message is displayed, use the launch option “Attach to Python”. Then press run, VS Code will now enter and debug any breakpoints you have set in your python algorithm.
-
-<br />
-
-_Figure 2: Python Debugger Messages_
-
-```
-20200715 17:12:06.546 Trace:: PythonInitializer.Initialize(): ended
-20200715 17:12:06.547 Trace:: DebuggerHelper.Initialize(): python initialization done
-20200715 17:12:06.547 Trace:: DebuggerHelper.Initialize(): starting...
-20200715 17:12:06.548 Trace:: DebuggerHelper.Initialize(): waiting for debugger to attach at localhost:5678...
-```
-
-<br />
-
-<h1>Common Issues</h1>
-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 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.

.vscode/settings.json

@@ -1,7 +0,0 @@
-{
-    "files.eol": "\n",
-    "python.analysis.extraPaths": [
-        "/Lean/Algorithm.Python",
-        "/opt/miniconda3/lib/python3.8/site-packages"
-    ]
-}

.vscode/tasks.json

@@ -1,67 +0,0 @@
-{
-    /*
-        VS Code Tasks for the LEAN engine
-        In order to use the build tasks you need msbuild on your system path.
-    */
-    "version": "2.0.0",
-    "tasks": [
-        {
-            "label": "build",
-            "type": "shell",
-            "command": "dotnet",
-            "args": [
-                "build",
-                "/p:Configuration=Debug",
-                "/p:DebugType=portable",
-                "/p:WarningLevel=1"
-            ],
-            "group": "build",
-            "presentation": {
-                "reveal": "silent"
-            },
-            "problemMatcher": "$msCompile"
-        },
-        {
-            "label": "rebuild",
-            "type": "shell",
-            "command": "dotnet",
-            "args": [
-                "build",
-                "--no-incremental",
-                "/p:Configuration=Debug",
-                "/p:DebugType=portable",
-                "/p:WarningLevel=1"
-            ],
-            "group": "build",
-            "presentation": {
-                "reveal": "silent"
-            },
-            "problemMatcher": "$msCompile"
-        },
-        {
-            "label": "clean",
-            "type": "shell",
-            "command": "dotnet",
-            "args": [
-                "clean",
-            ],
-            "group": "build",
-            "presentation": {
-                "reveal": "silent"
-            },
-            "problemMatcher": "$msCompile"
-        },
-        {
-            "label": "start research",
-            "type": "shell",
-            "dependsOn": ["build"],
-            "group": "build",
-            "isBackground": true,
-            "command" : "${workspaceFolder}/.vscode/launch_research.sh",
-            "args" : [
-                "${workspaceFolder}/Launcher/bin/Debug"
-            ],
-            "problemMatcher": "$msCompile"
-        }
-    ]
-}

Algorithm.CSharp/AccumulativeInsightPortfolioRegressionAlgorithm.cs

@@ -1,121 +0,0 @@
-/*
- * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
- * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
-*/
-
-using System;
-using System.Collections.Generic;
-using QuantConnect.Algorithm.Framework.Alphas;
-using QuantConnect.Algorithm.Framework.Execution;
-using QuantConnect.Algorithm.Framework.Portfolio;
-using QuantConnect.Algorithm.Framework.Selection;
-using QuantConnect.Interfaces;
-
-namespace QuantConnect.Algorithm.CSharp
-{
-    /// <summary>
-    /// Test algorithm using <see cref="AccumulativeInsightPortfolioConstructionModel"/> and <see cref="ConstantAlphaModel"/>
-    /// generating a constant <see cref="Insight"/> with a 0.25 confidence
-    /// </summary>
-    public class AccumulativeInsightPortfolioRegressionAlgorithm : 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()
-        {
-            // Set requested data resolution
-            UniverseSettings.Resolution = Resolution.Minute;
-
-            SetStartDate(2013, 10, 07);  //Set Start Date
-            SetEndDate(2013, 10, 11);    //Set End Date
-            SetCash(100000);             //Set Strategy Cash
-
-            // set algorithm framework models
-            SetUniverseSelection(new ManualUniverseSelectionModel(QuantConnect.Symbol.Create("SPY", SecurityType.Equity, Market.USA)));
-            SetAlpha(new ConstantAlphaModel(InsightType.Price, InsightDirection.Up, TimeSpan.FromMinutes(20), 0.025, 0.25));
-            SetPortfolioConstruction(new AccumulativeInsightPortfolioConstructionModel());
-            SetExecution(new ImmediateExecutionModel());
-        }
-
-        public override void OnEndOfAlgorithm()
-        {
-            if (// holdings value should be 0.03 - to avoid price fluctuation issue we compare with 0.06 and 0.01
-                Portfolio.TotalHoldingsValue > Portfolio.TotalPortfolioValue * 0.06m
-                ||
-                Portfolio.TotalHoldingsValue < Portfolio.TotalPortfolioValue * 0.01m)
-            {
-                throw new RegressionTestException($"Unexpected Total Holdings Value: {Portfolio.TotalHoldingsValue}");
-            }
-        }
-
-        /// <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 List<Language> Languages { get; } = new() { Language.CSharp, Language.Python };
-
-        /// <summary>
-        /// Data Points count of all timeslices of algorithm
-        /// </summary>
-        public long DataPoints => 3943;
-
-        /// <summary>
-        /// Data Points count of the algorithm history
-        /// </summary>
-        public int AlgorithmHistoryDataPoints => 0;
-
-        /// <summary>
-        /// Final status of the algorithm
-        /// </summary>
-        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
-
-        /// <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 Orders", "199"},
-            {"Average Win", "0.00%"},
-            {"Average Loss", "0.00%"},
-            {"Compounding Annual Return", "-12.611%"},
-            {"Drawdown", "0.200%"},
-            {"Expectancy", "-0.585"},
-            {"Start Equity", "100000"},
-            {"End Equity", "99827.80"},
-            {"Net Profit", "-0.172%"},
-            {"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.156"},
-            {"Beta", "0.035"},
-            {"Annual Standard Deviation", "0.008"},
-            {"Annual Variance", "0"},
-            {"Information Ratio", "-9.603"},
-            {"Tracking Error", "0.215"},
-            {"Treynor Ratio", "-2.478"},
-            {"Total Fees", "$199.00"},
-            {"Estimated Strategy Capacity", "$26000000.00"},
-            {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
-            {"Portfolio Turnover", "119.89%"},
-            {"OrderListHash", "d06c26f557b83d8d42ac808fe2815a1e"}
-        };
-    }
-}

Algorithm.CSharp/AddAlphaModelAlgorithm.cs

@@ -1,4 +1,4 @@
-/*
+/*
  * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
  * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
  *
@@ -66,7 +66,7 @@ namespace QuantConnect.Algorithm.CSharp
                 || insightsCollection.Insights.Count(insight => insight.Symbol == _spy) != 1
                 || insightsCollection.Insights.Count(insight => insight.Symbol == _ibm) != 1)
             {
-                throw new RegressionTestException("Unexpected insights were emitted");
+                throw new Exception("Unexpected insights were emitted");
             }
         }
 
@@ -103,55 +103,45 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// This is used by the regression test system to indicate which languages this algorithm is written in.
         /// </summary>
-        public List<Language> Languages { get; } = new() { Language.CSharp, Language.Python };
-
-        /// <summary>
-        /// Data Points count of all timeslices of algorithm
-        /// </summary>
-        public long DataPoints => 58;
-
-        /// <summary>
-        /// Data Points count of the algorithm history
-        /// </summary>
-        public int AlgorithmHistoryDataPoints => 0;
-
-        /// <summary>
-        /// Final status of the algorithm
-        /// </summary>
-        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
+        public Language[] Languages { get; } = { Language.CSharp, Language.Python };
 
         /// <summary>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
         /// </summary>
         public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
-            {"Total Orders", "9"},
-            {"Average Win", "0.86%"},
-            {"Average Loss", "-0.27%"},
-            {"Compounding Annual Return", "206.404%"},
-            {"Drawdown", "1.700%"},
-            {"Expectancy", "1.781"},
-            {"Start Equity", "100000"},
-            {"End Equity", "101441.92"},
-            {"Net Profit", "1.442%"},
-            {"Sharpe Ratio", "4.836"},
-            {"Sortino Ratio", "10.481"},
-            {"Probabilistic Sharpe Ratio", "59.497%"},
+            {"Total Trades", "6"},
+            {"Average Win", "0.91%"},
+            {"Average Loss", "-0.23%"},
+            {"Compounding Annual Return", "214.278%"},
+            {"Drawdown", "1.600%"},
+            {"Expectancy", "2.248"},
+            {"Net Profit", "1.581%"},
+            {"Sharpe Ratio", "2.803"},
             {"Loss Rate", "33%"},
             {"Win Rate", "67%"},
-            {"Profit-Loss Ratio", "3.17"},
-            {"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.174"},
-            {"Total Fees", "$14.78"},
-            {"Estimated Strategy Capacity", "$120000000.00"},
-            {"Lowest Capacity Asset", "IBM R735QTJ8XC9X"},
-            {"Portfolio Turnover", "41.18%"},
-            {"OrderListHash", "713c956deb193bed2290e9f379c0f9f9"}
+            {"Profit-Loss Ratio", "3.87"},
+            {"Alpha", "0"},
+            {"Beta", "59.491"},
+            {"Annual Standard Deviation", "0.244"},
+            {"Annual Variance", "0.06"},
+            {"Information Ratio", "2.756"},
+            {"Tracking Error", "0.244"},
+            {"Treynor Ratio", "0.012"},
+            {"Total Fees", "$10.88"},
+            {"Total Insights Generated", "3"},
+            {"Total Insights Closed", "3"},
+            {"Total Insights Analysis Completed", "3"},
+            {"Long Insight Count", "0"},
+            {"Short Insight Count", "3"},
+            {"Long/Short Ratio", "0%"},
+            {"Estimated Monthly Alpha Value", "$13262182.1037"},
+            {"Total Accumulated Estimated Alpha Value", "$2284042.4734"},
+            {"Mean Population Estimated Insight Value", "$761347.4911"},
+            {"Mean Population Direction", "100%"},
+            {"Mean Population Magnitude", "0%"},
+            {"Rolling Averaged Population Direction", "100%"},
+            {"Rolling Averaged Population Magnitude", "0%"}
         };
     }
 }

Algorithm.CSharp/AddAndRemoveOptionContractRegressionAlgorithm.cs

@@ -1,134 +0,0 @@
-/*
- * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
- * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
-*/
-
-using System;
-using System.Linq;
-using QuantConnect.Data;
-using QuantConnect.Interfaces;
-using System.Collections.Generic;
-
-namespace QuantConnect.Algorithm.CSharp
-{
-    /// <summary>
-    /// Regression algorithm reproducing GH issue #5748 where in some cases an option underlying symbol was not being
-    /// removed from all universes it was hold
-    /// </summary>
-    public class AddAndRemoveOptionContractRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
-    {
-        private Symbol _contract;
-        private bool _hasRemoved;
-
-        public override void Initialize()
-        {
-            SetStartDate(2014, 06, 06);
-            SetEndDate(2014, 06, 09);
-
-            UniverseSettings.DataNormalizationMode = DataNormalizationMode.Raw;
-            UniverseSettings.MinimumTimeInUniverse = TimeSpan.Zero;
-
-            var aapl = QuantConnect.Symbol.Create("AAPL", SecurityType.Equity, Market.USA);
-
-            _contract = OptionChain(aapl)
-                .OrderBy(x => x.ID.Symbol)
-                .FirstOrDefault(optionContract => optionContract.ID.OptionRight == OptionRight.Call
-                    && optionContract.ID.OptionStyle == OptionStyle.American);
-            AddOptionContract(_contract);
-        }
-
-        public override void OnData(Slice slice)
-        {
-            if (slice.HasData)
-            {
-                if (!_hasRemoved)
-                {
-                    RemoveOptionContract(_contract);
-                    RemoveSecurity(_contract.Underlying);
-                    _hasRemoved = true;
-                }
-                else
-                {
-                    throw new RegressionTestException("Expect a single call to OnData where we removed the option and underlying");
-                }
-            }
-        }
-
-        public override void OnEndOfAlgorithm()
-        {
-            if (!_hasRemoved)
-            {
-                throw new RegressionTestException("Expect a single call to OnData where we removed the option and underlying");
-            }
-        }
-
-        /// <summary>
-        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
-        /// </summary>
-        public bool CanRunLocally { get; } = true;
-
-        /// <summary>
-        /// This is used by the regression test system to indicate which languages this algorithm is written in.
-        /// </summary>
-        public List<Language> Languages { get; } = new() { Language.CSharp };
-
-        /// <summary>
-        /// Data Points count of all timeslices of algorithm
-        /// </summary>
-        public long DataPoints => 24;
-
-        /// <summary>
-        /// Data Points count of the algorithm history
-        /// </summary>
-        public int AlgorithmHistoryDataPoints => 1;
-
-        /// <summary>
-        /// Final status of the algorithm
-        /// </summary>
-        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
-
-        /// <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 Orders", "0"},
-            {"Average Win", "0%"},
-            {"Average Loss", "0%"},
-            {"Compounding Annual Return", "0%"},
-            {"Drawdown", "0%"},
-            {"Expectancy", "0"},
-            {"Start Equity", "100000"},
-            {"End Equity", "100000"},
-            {"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", "-9.486"},
-            {"Tracking Error", "0.008"},
-            {"Treynor Ratio", "0"},
-            {"Total Fees", "$0.00"},
-            {"Estimated Strategy Capacity", "$0"},
-            {"Lowest Capacity Asset", ""},
-            {"Portfolio Turnover", "0%"},
-            {"OrderListHash", "d41d8cd98f00b204e9800998ecf8427e"}
-        };
-    }
-}

Algorithm.CSharp/AddAndRemoveSecuritySameLoopRegressionAlgorithm.cs

@@ -1,131 +0,0 @@
-/*
- * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
- * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
-*/
-
-using System;
-using System.Linq;
-using QuantConnect.Data;
-using QuantConnect.Interfaces;
-using System.Collections.Generic;
-
-namespace QuantConnect.Algorithm.CSharp
-{
-    /// <summary>
-    /// Regression algorithm reproducing GH issue #5971 where we add and remove an option in the same loop
-    /// </summary>
-    public class AddAndRemoveSecuritySameLoopRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
-    {
-        private Symbol _contract;
-        private bool _hasRemoved;
-
-        public override void Initialize()
-        {
-            SetStartDate(2014, 06, 06);
-            SetEndDate(2014, 06, 09);
-
-            UniverseSettings.DataNormalizationMode = DataNormalizationMode.Raw;
-            UniverseSettings.MinimumTimeInUniverse = TimeSpan.Zero;
-
-            var aapl = AddEquity("AAPL").Symbol;
-
-            _contract = OptionChain(aapl)
-                .OrderBy(x => x.ID.Symbol)
-                .FirstOrDefault(optionContract => optionContract.ID.OptionRight == OptionRight.Call
-                    && optionContract.ID.OptionStyle == OptionStyle.American);
-        }
-
-        public override void OnData(Slice slice)
-        {
-            if (_hasRemoved)
-            {
-                throw new RegressionTestException("Expect a single call to OnData where we removed the option and underlying");
-            }
-
-            _hasRemoved = true;
-            AddOptionContract(_contract);
-
-            // changed my mind!
-            RemoveOptionContract(_contract);
-            RemoveSecurity(_contract.Underlying);
-
-            RemoveSecurity(AddEquity("SPY", Resolution.Daily).Symbol);
-        }
-        public override void OnEndOfAlgorithm()
-        {
-            if (!_hasRemoved)
-            {
-                throw new RegressionTestException("We did not remove the option contract!");
-            }
-        }
-
-        /// <summary>
-        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
-        /// </summary>
-        public bool CanRunLocally { get; } = true;
-
-        /// <summary>
-        /// This is used by the regression test system to indicate which languages this algorithm is written in.
-        /// </summary>
-        public List<Language> Languages { get; } = new() { Language.CSharp };
-
-        /// <summary>
-        /// Data Points count of all timeslices of algorithm
-        /// </summary>
-        public long DataPoints => 24;
-
-        /// <summary>
-        /// Data Points count of the algorithm history
-        /// </summary>
-        public int AlgorithmHistoryDataPoints => 1;
-
-        /// <summary>
-        /// Final status of the algorithm
-        /// </summary>
-        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
-
-        /// <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 Orders", "0"},
-            {"Average Win", "0%"},
-            {"Average Loss", "0%"},
-            {"Compounding Annual Return", "0%"},
-            {"Drawdown", "0%"},
-            {"Expectancy", "0"},
-            {"Start Equity", "100000"},
-            {"End Equity", "100000"},
-            {"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", "-9.486"},
-            {"Tracking Error", "0.008"},
-            {"Treynor Ratio", "0"},
-            {"Total Fees", "$0.00"},
-            {"Estimated Strategy Capacity", "$0"},
-            {"Lowest Capacity Asset", ""},
-            {"Portfolio Turnover", "0%"},
-            {"OrderListHash", "d41d8cd98f00b204e9800998ecf8427e"}
-        };
-    }
-}

Algorithm.CSharp/AddBetaIndicatorRegressionAlgorithm.cs

@@ -1,151 +0,0 @@
-/*
- * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
- * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
-*/
-
-using System;
-using System.Collections.Generic;
-using QuantConnect.Data;
-using QuantConnect.Indicators;
-using QuantConnect.Interfaces;
-using QuantConnect.Orders;
-
-namespace QuantConnect.Algorithm.CSharp
-{
-    /// <summary>
-    /// Regression test to explain how Beta indicator works
-    /// </summary>
-    public class AddBetaIndicatorRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
-    {
-        private Beta _beta;
-        private SimpleMovingAverage _sma;
-        private decimal _lastSMAValue;
-
-        public override void Initialize()
-        {
-            SetStartDate(2013, 10, 07);
-            SetEndDate(2013, 10, 15);
-            SetCash(10000);
-
-            AddEquity("IBM");
-            AddEquity("SPY");
-
-            EnableAutomaticIndicatorWarmUp = true;
-            _beta = B("IBM", "SPY", 3, Resolution.Daily);
-            _sma = SMA("SPY", 3, Resolution.Daily);
-            _lastSMAValue = 0;
-
-            if (!_beta.IsReady)
-            {
-                throw new RegressionTestException("_beta indicator was expected to be ready");
-            }
-        }
-
-        public override void OnData(Slice slice)
-        {
-            if (!Portfolio.Invested)
-            {
-                var price = slice["IBM"].Close;
-                Buy("IBM", 10);
-                LimitOrder("IBM", 10, price * 0.1m);
-                StopMarketOrder("IBM", 10, price / 0.1m);
-            }
-            
-            if (_beta.Current.Value < 0m || _beta.Current.Value > 2.80m)
-            {
-                throw new RegressionTestException($"_beta value was expected to be between 0 and 2.80 but was {_beta.Current.Value}");
-            }
-
-            Log($"Beta between IBM and SPY is: {_beta.Current.Value}");
-        }
-
-        public override void OnOrderEvent(OrderEvent orderEvent)
-        {
-            var order = Transactions.GetOrderById(orderEvent.OrderId);
-            var goUpwards = _lastSMAValue < _sma.Current.Value;
-            _lastSMAValue = _sma.Current.Value;
-
-            if (order.Status == OrderStatus.Filled)
-            {
-                if (order.Type == OrderType.Limit && Math.Abs(_beta.Current.Value - 1) < 0.2m && goUpwards)
-                {
-                    Transactions.CancelOpenOrders(order.Symbol);
-                }
-            }
-
-            if (order.Status == OrderStatus.Canceled)
-            {
-                Log(orderEvent.ToString());
-            }
-        }
-
-        /// <summary>
-        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
-        /// </summary>
-        public bool CanRunLocally { get; } = true;
-
-        /// <summary>
-        /// This is used by the regression test system to indicate which languages this algorithm is written in.
-        /// </summary>
-        public virtual List<Language> Languages { get; } = new() { Language.CSharp };
-
-        /// <summary>
-        /// Data Points count of all timeslices of algorithm
-        /// </summary>
-        public long DataPoints => 10977;
-
-        /// <summary>
-        /// Data Points count of the algorithm history
-        /// </summary>
-        public int AlgorithmHistoryDataPoints => 11;
-
-        /// <summary>
-        /// Final status of the algorithm
-        /// </summary>
-        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
-
-        /// <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 Orders", "3"},
-            {"Average Win", "0%"},
-            {"Average Loss", "0%"},
-            {"Compounding Annual Return", "12.939%"},
-            {"Drawdown", "0.300%"},
-            {"Expectancy", "0"},
-            {"Start Equity", "10000"},
-            {"End Equity", "10028.93"},
-            {"Net Profit", "0.289%"},
-            {"Sharpe Ratio", "3.924"},
-            {"Sortino Ratio", "0"},
-            {"Probabilistic Sharpe Ratio", "68.349%"},
-            {"Loss Rate", "0%"},
-            {"Win Rate", "0%"},
-            {"Profit-Loss Ratio", "0"},
-            {"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.78"},
-            {"Total Fees", "$1.00"},
-            {"Estimated Strategy Capacity", "$35000000.00"},
-            {"Lowest Capacity Asset", "IBM R735QTJ8XC9X"},
-            {"Portfolio Turnover", "1.51%"},
-            {"OrderListHash", "1db1ce949db995bba20ed96ea5e2438a"}
-        };
-    }
-}

Algorithm.CSharp/AddFutureContractWithContinuousRegressionAlgorithm.cs

@@ -1,164 +0,0 @@
-/*
- * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
- * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
-*/
-
-using System;
-using System.Linq;
-using QuantConnect.Data;
-using QuantConnect.Orders;
-using QuantConnect.Interfaces;
-using QuantConnect.Securities;
-using System.Collections.Generic;
-using QuantConnect.Securities.Future;
-using QuantConnect.Data.UniverseSelection;
-
-namespace QuantConnect.Algorithm.CSharp
-{
-    /// <summary>
-    /// Continuous Futures Regression algorithm. Asserting and showcasing the behavior of adding a continuous future
-    /// and a future contract at the same time
-    /// </summary>
-    public class AddFutureContractWithContinuousRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
-    {
-        private Future _continuousContract;
-        private Future _futureContract;
-        private bool _ended;
-
-        /// <summary>
-        /// Initialise the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must initialized.
-        /// </summary>
-        public override void Initialize()
-        {
-            SetStartDate(2013, 10, 6);
-            SetEndDate(2013, 10, 10);
-
-            _continuousContract = AddFuture(Futures.Indices.SP500EMini,
-                dataNormalizationMode: DataNormalizationMode.BackwardsRatio,
-                dataMappingMode: DataMappingMode.LastTradingDay,
-                contractDepthOffset: 0
-            );
-
-            _futureContract = AddFutureContract(FutureChainProvider.GetFutureContractList(_continuousContract.Symbol, Time).First());
-        }
-
-        /// <summary>
-        /// OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here.
-        /// </summary>
-        /// <param name="slice">Slice object keyed by symbol containing the stock data</param>
-        public override void OnData(Slice slice)
-        {
-            if (_ended)
-            {
-                throw new RegressionTestException($"Algorithm should of ended!");
-            }
-            if (slice.Keys.Count > 2)
-            {
-                throw new RegressionTestException($"Getting data for more than 2 symbols! {string.Join(",", slice.Keys.Select(symbol => symbol))}");
-            }
-            if (UniverseManager.Count != 3)
-            {
-                throw new RegressionTestException($"Expecting 3 universes (chain, continuous and user defined) but have {UniverseManager.Count}");
-            }
-
-            if (!Portfolio.Invested)
-            {
-                Buy(_futureContract.Symbol, 1);
-                Buy(_continuousContract.Mapped, 1);
-
-                RemoveSecurity(_futureContract.Symbol);
-                RemoveSecurity(_continuousContract.Symbol);
-
-                _ended = true;
-            }
-        }
-
-        public override void OnOrderEvent(OrderEvent orderEvent)
-        {
-            if (orderEvent.Status == OrderStatus.Filled)
-            {
-                Log($"{orderEvent}");
-            }
-        }
-
-        public override void OnSecuritiesChanged(SecurityChanges changes)
-        {
-            Debug($"{Time}-{changes}");
-
-            if (changes.AddedSecurities.Any(security => security.Symbol != _continuousContract.Symbol && security.Symbol != _futureContract.Symbol)
-                || changes.RemovedSecurities.Any(security => security.Symbol != _continuousContract.Symbol && security.Symbol != _futureContract.Symbol))
-            {
-                throw new RegressionTestException($"We got an unexpected security changes {changes}");
-            }
-        }
-
-        /// <summary>
-        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
-        /// </summary>
-        public bool CanRunLocally { get; } = true;
-
-        /// <summary>
-        /// This is used by the regression test system to indicate which languages this algorithm is written in.
-        /// </summary>
-        public List<Language> Languages { get; } = new() { Language.CSharp };
-
-        /// <summary>
-        /// Data Points count of all timeslices of algorithm
-        /// </summary>
-        public long DataPoints => 76;
-
-        /// <summary>
-        /// Data Points count of the algorithm history
-        /// </summary>
-        public int AlgorithmHistoryDataPoints => 0;
-
-        /// <summary>
-        /// Final status of the algorithm
-        /// </summary>
-        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
-
-        /// <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 Orders", "3"},
-            {"Average Win", "0%"},
-            {"Average Loss", "-0.03%"},
-            {"Compounding Annual Return", "-2.594%"},
-            {"Drawdown", "0.000%"},
-            {"Expectancy", "-1"},
-            {"Start Equity", "100000"},
-            {"End Equity", "99966.4"},
-            {"Net Profit", "-0.034%"},
-            {"Sharpe Ratio", "-10.666"},
-            {"Sortino Ratio", "0"},
-            {"Probabilistic Sharpe Ratio", "1.216%"},
-            {"Loss Rate", "100%"},
-            {"Win Rate", "0%"},
-            {"Profit-Loss Ratio", "0"},
-            {"Alpha", "-0.029"},
-            {"Beta", "0.004"},
-            {"Annual Standard Deviation", "0.003"},
-            {"Annual Variance", "0"},
-            {"Information Ratio", "-0.768"},
-            {"Tracking Error", "0.241"},
-            {"Treynor Ratio", "-6.368"},
-            {"Total Fees", "$8.60"},
-            {"Estimated Strategy Capacity", "$5500000.00"},
-            {"Lowest Capacity Asset", "ES VMKLFZIH2MTD"},
-            {"Portfolio Turnover", "66.80%"},
-            {"OrderListHash", "579e2e83dd7e5e7648c47e9eff132460"}
-        };
-    }
-}

Algorithm.CSharp/AddFutureOptionContractDataStreamingRegressionAlgorithm.cs

@@ -1,213 +0,0 @@
-/*
- * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
- * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
-*/
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using QuantConnect.Data;
-using QuantConnect.Data.Market;
-using QuantConnect.Interfaces;
-using QuantConnect.Securities;
-
-namespace QuantConnect.Algorithm.CSharp
-{
-    /// <summary>
-    /// This regression algorithm tests that we receive the expected data when
-    /// we add future option contracts individually using <see cref="AddFutureOptionContract"/>
-    /// </summary>
-    public class AddFutureOptionContractDataStreamingRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
-    {
-        private bool _onDataReached;
-        private bool _invested;
-        private Symbol _es20h20;
-        private Symbol _es19m20;
-
-        private readonly HashSet<Symbol> _symbolsReceived = new HashSet<Symbol>();
-        private readonly HashSet<Symbol> _expectedSymbolsReceived = new HashSet<Symbol>();
-        private readonly Dictionary<Symbol, List<QuoteBar>> _dataReceived = new Dictionary<Symbol, List<QuoteBar>>();
-
-        public override void Initialize()
-        {
-            SetStartDate(2020, 1, 4);
-            SetEndDate(2020, 1, 8);
-
-            _es20h20 = AddFutureContract(
-                QuantConnect.Symbol.CreateFuture(Futures.Indices.SP500EMini, Market.CME, new DateTime(2020, 3, 20)),
-                Resolution.Minute).Symbol;
-
-            _es19m20 = AddFutureContract(
-                QuantConnect.Symbol.CreateFuture(Futures.Indices.SP500EMini, Market.CME, new DateTime(2020, 6, 19)),
-                Resolution.Minute).Symbol;
-
-            // Get option contract lists for 2020/01/05 (Time.AddDays(1)) because Lean has local data for that date
-            var optionChains = OptionChainProvider.GetOptionContractList(_es20h20, Time.AddDays(1))
-                .Concat(OptionChainProvider.GetOptionContractList(_es19m20, Time.AddDays(1)));
-
-            foreach (var optionContract in optionChains)
-            {
-                _expectedSymbolsReceived.Add(AddFutureOptionContract(optionContract, Resolution.Minute).Symbol);
-            }
-
-            if (_expectedSymbolsReceived.Count == 0)
-            {
-                throw new InvalidOperationException("Expected Symbols receive count is 0, expected >0");
-            }
-        }
-
-        public override void OnData(Slice slice)
-        {
-            if (!slice.HasData)
-            {
-                return;
-            }
-
-            _onDataReached = true;
-
-            var hasOptionQuoteBars = false;
-            foreach (var qb in slice.QuoteBars.Values)
-            {
-                if (qb.Symbol.SecurityType != SecurityType.FutureOption)
-                {
-                    continue;
-                }
-
-                hasOptionQuoteBars = true;
-
-                _symbolsReceived.Add(qb.Symbol);
-                if (!_dataReceived.ContainsKey(qb.Symbol))
-                {
-                    _dataReceived[qb.Symbol] = new List<QuoteBar>();
-                }
-
-                _dataReceived[qb.Symbol].Add(qb);
-            }
-
-            if (_invested || !hasOptionQuoteBars)
-            {
-                return;
-            }
-
-            if (slice.ContainsKey(_es20h20) && slice.ContainsKey(_es19m20))
-            {
-                SetHoldings(_es20h20, 0.2);
-                SetHoldings(_es19m20, 0.2);
-
-                _invested = true;
-            }
-        }
-
-        public override void OnEndOfAlgorithm()
-        {
-            base.OnEndOfAlgorithm();
-
-            if (!_onDataReached)
-            {
-                throw new RegressionTestException("OnData() was never called.");
-            }
-            if (_symbolsReceived.Count != _expectedSymbolsReceived.Count)
-            {
-                throw new AggregateException($"Expected {_expectedSymbolsReceived.Count} option contracts Symbols, found {_symbolsReceived.Count}");
-            }
-
-            var missingSymbols = new List<Symbol>();
-            foreach (var expectedSymbol in _expectedSymbolsReceived)
-            {
-                if (!_symbolsReceived.Contains(expectedSymbol))
-                {
-                    missingSymbols.Add(expectedSymbol);
-                }
-            }
-
-            if (missingSymbols.Count > 0)
-            {
-                throw new RegressionTestException($"Symbols: \"{string.Join(", ", missingSymbols)}\" were not found in OnData");
-            }
-
-            foreach (var expectedSymbol in _expectedSymbolsReceived)
-            {
-                var data = _dataReceived[expectedSymbol];
-                var nonDupeDataCount = data.Select(x =>
-                {
-                    x.EndTime = default(DateTime);
-                    return x;
-                }).Distinct().Count();
-
-                if (nonDupeDataCount < 1000)
-                {
-                    throw new RegressionTestException($"Received too few data points. Expected >=1000, found {nonDupeDataCount} for {expectedSymbol}");
-                }
-            }
-        }
-
-        /// <summary>
-        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
-        /// </summary>
-        public bool CanRunLocally { get; } = true;
-
-        /// <summary>
-        /// This is used by the regression test system to indicate which languages this algorithm is written in.
-        /// </summary>
-        public List<Language> Languages { get; } = new() { Language.CSharp, Language.Python };
-
-        /// <summary>
-        /// Data Points count of all timeslices of algorithm
-        /// </summary>
-        public long DataPoints => 311881;
-
-        /// <summary>
-        /// Data Points count of the algorithm history
-        /// </summary>
-        public int AlgorithmHistoryDataPoints => 0;
-
-        /// <summary>
-        /// Final status of the algorithm
-        /// </summary>
-        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
-
-        /// <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 Orders", "2"},
-            {"Average Win", "0%"},
-            {"Average Loss", "0%"},
-            {"Compounding Annual Return", "5512.811%"},
-            {"Drawdown", "1.000%"},
-            {"Expectancy", "0"},
-            {"Start Equity", "100000"},
-            {"End Equity", "105332.8"},
-            {"Net Profit", "5.333%"},
-            {"Sharpe Ratio", "64.084"},
-            {"Sortino Ratio", "0"},
-            {"Probabilistic Sharpe Ratio", "95.977%"},
-            {"Loss Rate", "0%"},
-            {"Win Rate", "0%"},
-            {"Profit-Loss Ratio", "0"},
-            {"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.308"},
-            {"Total Fees", "$8.60"},
-            {"Estimated Strategy Capacity", "$22000000.00"},
-            {"Lowest Capacity Asset", "ES XFH59UK0MYO1"},
-            {"Portfolio Turnover", "122.11%"},
-            {"OrderListHash", "d744fa8beaa60546c84924ed68d945d9"}
-        };
-    }
-}

Algorithm.CSharp/AddFutureOptionContractFromFutureChainRegressionAlgorithm.cs

@@ -1,142 +0,0 @@
-/*
- * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
- * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
-*/
-
-using QuantConnect.Data;
-using QuantConnect.Interfaces;
-using QuantConnect.Securities;
-using System.Collections.Generic;
-using System.Linq;
-
-namespace QuantConnect.Algorithm.CSharp
-{
-    /// <summary>
-    /// This regression algorithm tests we can add future option contracts from contracts in the future chain
-    /// </summary>
-    public class AddFutureOptionContractFromFutureChainRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
-    {
-        private bool _addedOptions;
-
-        public override void Initialize()
-        {
-            SetStartDate(2020, 1, 4);
-            SetEndDate(2020, 1, 6);
-
-            var es = AddFuture(Futures.Indices.SP500EMini, Resolution.Minute, Market.CME);
-            es.SetFilter((futureFilter) =>
-            {
-                return futureFilter.Expiration(0, 365).ExpirationCycle(new[] { 3, 6 });
-            });
-        }
-
-        public override void OnData(Slice slice)
-        {
-            if (!_addedOptions)
-            {
-                _addedOptions = true;
-                foreach (var futuresContracts in slice.FutureChains.Values)
-                {
-                    foreach (var contract in futuresContracts)
-                    {
-                        var option_contract_symbols = OptionChain(contract.Symbol).ToList();
-                        if(option_contract_symbols.Count == 0)
-                        {
-                            continue;
-                        }
-
-                        foreach (var option_contract_symbol in option_contract_symbols.OrderBy(x => x.ID.Date)
-                            .ThenBy(x => x.ID.StrikePrice)
-                            .ThenBy(x => x.ID.OptionRight).Take(5))
-                        {
-                            AddOptionContract(option_contract_symbol);
-                        }
-                    }
-                }
-            }
-
-            if (Portfolio.Invested)
-            {
-                return;
-            }
-
-            foreach (var chain in slice.OptionChains.Values)
-            {
-                foreach (var option in chain.Contracts.Keys)
-                {
-                    MarketOrder(option, 1);
-                    MarketOrder(option.Underlying, 1);
-                }
-            }
-        }
-
-        /// <summary>
-        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
-        /// </summary>
-        public bool CanRunLocally { get; } = true;
-
-        /// <summary>
-        /// This is used by the regression test system to indicate which languages this algorithm is written in.
-        /// </summary>
-        public List<Language> Languages { get; } = new() { Language.CSharp };
-
-        /// <summary>
-        /// Data Points count of all timeslices of algorithm
-        /// </summary>
-        public long DataPoints => 12172;
-
-        /// <summary>
-        /// Data Points count of the algorithm history
-        /// </summary>
-        public int AlgorithmHistoryDataPoints => 0;
-
-        /// <summary>
-        /// Final status of the algorithm
-        /// </summary>
-        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
-
-        /// <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 Orders", "20"},
-            {"Average Win", "0%"},
-            {"Average Loss", "0%"},
-            {"Compounding Annual Return", "386219349.202%"},
-            {"Drawdown", "5.200%"},
-            {"Expectancy", "0"},
-            {"Start Equity", "100000"},
-            {"End Equity", "111911.55"},
-            {"Net Profit", "11.912%"},
-            {"Sharpe Ratio", "1604181.904"},
-            {"Sortino Ratio", "0"},
-            {"Probabilistic Sharpe Ratio", "0%"},
-            {"Loss Rate", "0%"},
-            {"Win Rate", "0%"},
-            {"Profit-Loss Ratio", "0"},
-            {"Alpha", "2144882.02"},
-            {"Beta", "31.223"},
-            {"Annual Standard Deviation", "1.337"},
-            {"Annual Variance", "1.788"},
-            {"Information Ratio", "1657259.526"},
-            {"Tracking Error", "1.294"},
-            {"Treynor Ratio", "68696.045"},
-            {"Total Fees", "$35.70"},
-            {"Estimated Strategy Capacity", "$2600000.00"},
-            {"Lowest Capacity Asset", "ES 31C3JQS9D84PW|ES XCZJLC9NOB29"},
-            {"Portfolio Turnover", "495.15%"},
-            {"OrderListHash", "85257286f088992d599c1ad0799a6237"}
-        };
-    }
-}

Algorithm.CSharp/AddFutureOptionSingleOptionChainSelectedInUniverseFilterRegressionAlgorithm.cs

@@ -1,269 +0,0 @@
-/*
- * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
- * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
-*/
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using QuantConnect.Data;
-using QuantConnect.Data.Market;
-using QuantConnect.Interfaces;
-using QuantConnect.Securities;
-using QuantConnect.Securities.Future;
-using QuantConnect.Securities.Option;
-
-namespace QuantConnect.Algorithm.CSharp
-{
-    /// <summary>
-    /// This regression algorithm tests that we only receive the option chain for a single future contract
-    /// in the option universe filter.
-    /// </summary>
-    public class AddFutureOptionSingleOptionChainSelectedInUniverseFilterRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
-    {
-        private bool _invested;
-        private bool _onDataReached;
-        private bool _optionFilterRan;
-        private readonly HashSet<Symbol> _symbolsReceived = new HashSet<Symbol>();
-        private readonly HashSet<Symbol> _expectedSymbolsReceived = new HashSet<Symbol>();
-        private readonly Dictionary<Symbol, List<QuoteBar>> _dataReceived = new Dictionary<Symbol, List<QuoteBar>>();
-
-        private Future _es;
-
-        public override void Initialize()
-        {
-            SetStartDate(2020, 1, 4);
-            SetEndDate(2020, 1, 8);
-
-            _es = AddFuture(Futures.Indices.SP500EMini, Resolution.Minute, Market.CME);
-            _es.SetFilter((futureFilter) =>
-            {
-                return futureFilter.Expiration(0, 365).ExpirationCycle(new[] { 3, 6 });
-            });
-
-            AddFutureOption(_es.Symbol, optionContracts =>
-            {
-                _optionFilterRan = true;
-
-                var expiry = new HashSet<DateTime>(optionContracts.Select(x => x.Symbol.Underlying.ID.Date)).SingleOrDefault();
-                // Cast to List<Symbol> because OptionFilterContract overrides some LINQ operators like `Select` and `Where`
-                // and cause it to mutate the underlying Symbol collection when using those operators.
-                var symbol = new HashSet<Symbol>(((List<Symbol>)optionContracts).Select(x => x.Underlying)).SingleOrDefault();
-
-                if (expiry == null || symbol == null)
-                {
-                    throw new InvalidOperationException("Expected a single Option contract in the chain, found 0 contracts");
-                }
-
-                var enumerator = optionContracts.GetEnumerator();
-                while (enumerator.MoveNext())
-                {
-                    _expectedSymbolsReceived.Add(enumerator.Current);
-                }
-
-                return optionContracts;
-            });
-        }
-
-        public override void OnData(Slice slice)
-        {
-            if (!slice.HasData)
-            {
-                return;
-            }
-
-            _onDataReached = true;
-
-            var hasOptionQuoteBars = false;
-            foreach (var qb in slice.QuoteBars.Values)
-            {
-                if (qb.Symbol.SecurityType != SecurityType.FutureOption)
-                {
-                    continue;
-                }
-
-                hasOptionQuoteBars = true;
-
-                _symbolsReceived.Add(qb.Symbol);
-                if (!_dataReceived.ContainsKey(qb.Symbol))
-                {
-                    _dataReceived[qb.Symbol] = new List<QuoteBar>();
-                }
-
-                _dataReceived[qb.Symbol].Add(qb);
-            }
-
-            if (_invested || !hasOptionQuoteBars)
-            {
-                return;
-            }
-
-            foreach (var chain in slice.OptionChains.Values)
-            {
-                var futureInvested = false;
-                var optionInvested = false;
-
-                foreach (var option in chain.Contracts.Keys)
-                {
-                    if (futureInvested && optionInvested)
-                    {
-                        return;
-                    }
-
-                    var future = option.Underlying;
-
-                    if (!optionInvested && slice.ContainsKey(option))
-                    {
-                        var optionContract = Securities[option];
-                        var marginModel = optionContract.BuyingPowerModel as FuturesOptionsMarginModel;
-                        if (marginModel.InitialIntradayMarginRequirement == 0
-                            || marginModel.InitialOvernightMarginRequirement == 0
-                            || marginModel.MaintenanceIntradayMarginRequirement == 0
-                            || marginModel.MaintenanceOvernightMarginRequirement == 0)
-                        {
-                            throw new RegressionTestException("Unexpected margin requirements");
-                        }
-
-                        if (marginModel.GetInitialMarginRequirement(optionContract, 1) == 0)
-                        {
-                            throw new RegressionTestException("Unexpected Initial Margin requirement");
-                        }
-                        if (marginModel.GetMaintenanceMargin(optionContract) != 0)
-                        {
-                            throw new RegressionTestException("Unexpected Maintenance Margin requirement");
-                        }
-
-                        MarketOrder(option, 1);
-                        _invested = true;
-                        optionInvested = true;
-
-                        if (marginModel.GetMaintenanceMargin(optionContract) == 0)
-                        {
-                            throw new RegressionTestException("Unexpected Maintenance Margin requirement");
-                        }
-                    }
-                    if (!futureInvested && slice.ContainsKey(future))
-                    {
-                        MarketOrder(future, 1);
-                        _invested = true;
-                        futureInvested = true;
-                    }
-                }
-            }
-        }
-
-        public override void OnEndOfAlgorithm()
-        {
-            if (!_optionFilterRan)
-            {
-                throw new InvalidOperationException("Option chain filter was never ran");
-            }
-            if (!_onDataReached)
-            {
-                throw new RegressionTestException("OnData() was never called.");
-            }
-            if (_symbolsReceived.Count != _expectedSymbolsReceived.Count)
-            {
-                throw new AggregateException($"Expected {_expectedSymbolsReceived.Count} option contracts Symbols, found {_symbolsReceived.Count}");
-            }
-
-            var missingSymbols = new List<Symbol>();
-            foreach (var expectedSymbol in _expectedSymbolsReceived)
-            {
-                if (!_symbolsReceived.Contains(expectedSymbol))
-                {
-                    missingSymbols.Add(expectedSymbol);
-                }
-            }
-
-            if (missingSymbols.Count > 0)
-            {
-                throw new RegressionTestException($"Symbols: \"{string.Join(", ", missingSymbols)}\" were not found in OnData");
-            }
-
-            foreach (var expectedSymbol in _expectedSymbolsReceived)
-            {
-                var data = _dataReceived[expectedSymbol];
-                var nonDupeDataCount = data.Select(x =>
-                {
-                    x.EndTime = default(DateTime);
-                    return x;
-                }).Distinct().Count();
-
-                if (nonDupeDataCount < 1000)
-                {
-                    throw new RegressionTestException($"Received too few data points. Expected >=1000, found {nonDupeDataCount} for {expectedSymbol}");
-                }
-            }
-        }
-
-        /// <summary>
-        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
-        /// </summary>
-        public bool CanRunLocally { get; } = true;
-
-        /// <summary>
-        /// This is used by the regression test system to indicate which languages this algorithm is written in.
-        /// </summary>
-        public List<Language> Languages { get; } = new() { Language.CSharp, Language.Python };
-
-        /// <summary>
-        /// Data Points count of all timeslices of algorithm
-        /// </summary>
-        public long DataPoints => 608380;
-
-        /// <summary>
-        /// Data Points count of the algorithm history
-        /// </summary>
-        public int AlgorithmHistoryDataPoints => 0;
-
-        /// <summary>
-        /// Final status of the algorithm
-        /// </summary>
-        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
-
-        /// <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 Orders", "2"},
-            {"Average Win", "0%"},
-            {"Average Loss", "0%"},
-            {"Compounding Annual Return", "347.065%"},
-            {"Drawdown", "0.900%"},
-            {"Expectancy", "0"},
-            {"Start Equity", "100000"},
-            {"End Equity", "101950.53"},
-            {"Net Profit", "1.951%"},
-            {"Sharpe Ratio", "15.402"},
-            {"Sortino Ratio", "0"},
-            {"Probabilistic Sharpe Ratio", "95.977%"},
-            {"Loss Rate", "0%"},
-            {"Win Rate", "0%"},
-            {"Profit-Loss Ratio", "0"},
-            {"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.237"},
-            {"Total Fees", "$3.57"},
-            {"Estimated Strategy Capacity", "$760000.00"},
-            {"Lowest Capacity Asset", "ES XCZJLDQX2SRO|ES XCZJLC9NOB29"},
-            {"Portfolio Turnover", "32.31%"},
-            {"OrderListHash", "7a04f66a30d793bf187c2695781ad3ee"}
-        };
-    }
-}

Algorithm.CSharp/AddOptionContractExpiresRegressionAlgorithm.cs

@@ -1,166 +0,0 @@
-/*
- * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
- * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
-*/
-
-using System;
-using System.Linq;
-using QuantConnect.Data;
-using QuantConnect.Interfaces;
-using System.Collections.Generic;
-
-namespace QuantConnect.Algorithm.CSharp
-{
-    /// <summary>
-    /// We add an option contract using <see cref="QCAlgorithm.AddOptionContract"/> and place a trade and wait till it expires
-    /// later will liquidate the resulting equity position and assert both option and underlying get removed
-    /// </summary>
-    public class AddOptionContractExpiresRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
-    {
-        private DateTime _expiration = new DateTime(2014, 06, 21);
-        private Symbol _option;
-        private Symbol _twx;
-        private bool _traded;
-
-        public override void Initialize()
-        {
-            SetStartDate(2014, 06, 05);
-            SetEndDate(2014, 06, 30);
-
-            _twx = QuantConnect.Symbol.Create("TWX", SecurityType.Equity, Market.USA);
-
-            AddUniverse("my-daily-universe-name", time => new List<string> { "AAPL" });
-        }
-
-        public override void OnData(Slice slice)
-        {
-            if (_option == null)
-            {
-                var option = OptionChain(_twx)
-                    .OrderBy(x => x.ID.Symbol)
-                    .FirstOrDefault(optionContract => optionContract.ID.Date == _expiration
-                                                      && optionContract.ID.OptionRight == OptionRight.Call
-                                                      && optionContract.ID.OptionStyle == OptionStyle.American);
-                if (option != null)
-                {
-                    _option = AddOptionContract(option).Symbol;
-                }
-            }
-
-            if (_option != null && Securities[_option].Price != 0 && !_traded)
-            {
-                _traded = true;
-                Buy(_option, 1);
-
-                foreach (var symbol in new [] { _option, _option.Underlying })
-                {
-                    var config = SubscriptionManager.SubscriptionDataConfigService.GetSubscriptionDataConfigs(symbol).ToList();
-
-                    if (!config.Any())
-                    {
-                        throw new RegressionTestException($"Was expecting configurations for {symbol}");
-                    }
-                    if (config.Any(dataConfig => dataConfig.DataNormalizationMode != DataNormalizationMode.Raw))
-                    {
-                        throw new RegressionTestException($"Was expecting DataNormalizationMode.Raw configurations for {symbol}");
-                    }
-                }
-            }
-
-            if (Time.Date > _expiration)
-            {
-                if (SubscriptionManager.SubscriptionDataConfigService.GetSubscriptionDataConfigs(_option).Any())
-                {
-                    throw new RegressionTestException($"Unexpected configurations for {_option} after it has been delisted");
-                }
-
-                if (Securities[_twx].Invested)
-                {
-                    if (!SubscriptionManager.SubscriptionDataConfigService.GetSubscriptionDataConfigs(_twx).Any())
-                    {
-                        throw new RegressionTestException($"Was expecting configurations for {_twx}");
-                    }
-
-                    // first we liquidate the option exercised position
-                    Liquidate(_twx);
-                }
-            }
-            else if (Time.Date > _expiration && !Securities[_twx].Invested)
-            {
-                if (SubscriptionManager.SubscriptionDataConfigService.GetSubscriptionDataConfigs(_twx).Any())
-                {
-                    throw new RegressionTestException($"Unexpected configurations for {_twx} after it has been liquidated");
-                }
-            }
-        }
-
-        /// <summary>
-        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
-        /// </summary>
-        public bool CanRunLocally { get; } = true;
-
-        /// <summary>
-        /// This is used by the regression test system to indicate which languages this algorithm is written in.
-        /// </summary>
-        public List<Language> Languages { get; } = new() { Language.CSharp, Language.Python };
-
-        /// <summary>
-        /// Data Points count of all timeslices of algorithm
-        /// </summary>
-        public long DataPoints => 37597;
-
-        /// <summary>
-        /// Data Points count of the algorithm history
-        /// </summary>
-        public int AlgorithmHistoryDataPoints => 1;
-
-        /// <summary>
-        /// Final status of the algorithm
-        /// </summary>
-        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
-
-        /// <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 Orders", "3"},
-            {"Average Win", "2.73%"},
-            {"Average Loss", "-2.98%"},
-            {"Compounding Annual Return", "-4.619%"},
-            {"Drawdown", "0.300%"},
-            {"Expectancy", "-0.042"},
-            {"Start Equity", "100000"},
-            {"End Equity", "99668"},
-            {"Net Profit", "-0.332%"},
-            {"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.022"},
-            {"Beta", "-0.012"},
-            {"Annual Standard Deviation", "0.005"},
-            {"Annual Variance", "0"},
-            {"Information Ratio", "-2.823"},
-            {"Tracking Error", "0.049"},
-            {"Treynor Ratio", "2.01"},
-            {"Total Fees", "$2.00"},
-            {"Estimated Strategy Capacity", "$5700000.00"},
-            {"Lowest Capacity Asset", "AOL VRKS95ENLBYE|AOL R735QTJ8XC9X"},
-            {"Portfolio Turnover", "0.55%"},
-            {"OrderListHash", "24191a4a3bf11c07622a21266618193d"}
-        };
-    }
-}

Algorithm.CSharp/AddOptionContractFromUniverseRegressionAlgorithm.cs

@@ -1,218 +0,0 @@
-/*
- * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
- * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
-*/
-
-using QuantConnect.Data;
-using QuantConnect.Data.UniverseSelection;
-using QuantConnect.Interfaces;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-
-namespace QuantConnect.Algorithm.CSharp
-{
-    /// <summary>
-    /// We add an option contract using <see cref="QCAlgorithm.AddOptionContract"/> and place a trade, the underlying
-    /// gets deselected from the universe selection but should still be present since we manually added the option contract.
-    /// Later we call <see cref="QCAlgorithm.RemoveOptionContract"/> and expect both option and underlying to be removed.
-    /// </summary>
-    public class AddOptionContractFromUniverseRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
-    {
-        private DateTime _expiration = new DateTime(2014, 06, 21);
-        private SecurityChanges _securityChanges = SecurityChanges.None;
-        private Symbol _option;
-        private Symbol _aapl;
-        private Symbol _twx;
-        private bool _traded;
-
-        public override void Initialize()
-        {
-            _twx = QuantConnect.Symbol.Create("TWX", SecurityType.Equity, Market.USA);
-            _aapl = QuantConnect.Symbol.Create("AAPL", SecurityType.Equity, Market.USA);
-            UniverseSettings.Resolution = Resolution.Minute;
-            UniverseSettings.DataNormalizationMode = DataNormalizationMode.Raw;
-
-            SetStartDate(2014, 06, 05);
-            SetEndDate(2014, 06, 09);
-
-            AddUniverse(enumerable => new[] { Time.Date <= new DateTime(2014, 6, 5) ? _twx : _aapl },
-                enumerable => new[] { Time.Date <= new DateTime(2014, 6, 5) ? _twx : _aapl });
-        }
-
-        public override void OnData(Slice slice)
-        {
-            if (_option != null && Securities[_option].Price != 0 && !_traded)
-            {
-                _traded = true;
-                Buy(_option, 1);
-            }
-
-            if (Time.Date > new DateTime(2014, 6, 5))
-            {
-                if (Time < new DateTime(2014, 6, 6, 14, 0, 0))
-                {
-                    var configs = SubscriptionManager.SubscriptionDataConfigService.GetSubscriptionDataConfigs(_twx);
-                    // assert underlying still there after the universe selection removed it, still used by the manually added option contract
-                    if (!configs.Any())
-                    {
-                        throw new RegressionTestException($"Was expecting configurations for {_twx}" +
-                                            $" even after it has been deselected from coarse universe because we still have the option contract.");
-                    }
-                }
-                else if (Time == new DateTime(2014, 6, 6, 14, 0, 0))
-                {
-                    // liquidate & remove the option
-                    RemoveOptionContract(_option);
-                }
-                // assert underlying was finally removed
-                else if(Time > new DateTime(2014, 6, 6, 14, 0, 0))
-                {
-                    foreach (var symbol in new[] { _option, _option.Underlying })
-                    {
-                        var configs = SubscriptionManager.SubscriptionDataConfigService.GetSubscriptionDataConfigs(symbol);
-                        if (configs.Any())
-                        {
-                            throw new RegressionTestException($"Unexpected configuration for {symbol} after it has been deselected from coarse universe and option contract is removed.");
-                        }
-                    }
-                }
-            }
-        }
-
-        public override void OnSecuritiesChanged(SecurityChanges changes)
-        {
-            if (_securityChanges.RemovedSecurities.Intersect(changes.RemovedSecurities).Any())
-            {
-                throw new RegressionTestException($"SecurityChanges.RemovedSecurities intersect {changes.RemovedSecurities}. We expect no duplicate!");
-            }
-            if (_securityChanges.AddedSecurities.Intersect(changes.AddedSecurities).Any())
-            {
-                throw new RegressionTestException($"SecurityChanges.AddedSecurities intersect {changes.RemovedSecurities}. We expect no duplicate!");
-            }
-            // keep track of all removed and added securities
-            _securityChanges += changes;
-
-            if (changes.AddedSecurities.Any(security => security.Symbol.SecurityType == SecurityType.Option))
-            {
-                return;
-            }
-
-            foreach (var addedSecurity in changes.AddedSecurities)
-            {
-                var option = OptionChain(addedSecurity.Symbol)
-                    .OrderBy(contractData => contractData.ID.Symbol)
-                    .First(optionContract => optionContract.ID.Date == _expiration
-                                                      && optionContract.ID.OptionRight == OptionRight.Call
-                                                      && optionContract.ID.OptionStyle == OptionStyle.American);
-                AddOptionContract(option);
-
-                foreach (var symbol in new[] { option.Symbol, option.UnderlyingSymbol })
-                {
-                    var config = SubscriptionManager.SubscriptionDataConfigService.GetSubscriptionDataConfigs(symbol).ToList();
-
-                    if (!config.Any())
-                    {
-                        throw new RegressionTestException($"Was expecting configurations for {symbol}");
-                    }
-                    if (config.Any(dataConfig => dataConfig.DataNormalizationMode != DataNormalizationMode.Raw))
-                    {
-                        throw new RegressionTestException($"Was expecting DataNormalizationMode.Raw configurations for {symbol}");
-                    }
-                }
-
-                // just keep the first we got
-                if (_option == null)
-                {
-                    _option = option;
-                }
-            }
-        }
-
-        public override void OnEndOfAlgorithm()
-        {
-            if (SubscriptionManager.Subscriptions.Any(dataConfig => dataConfig.Symbol == _twx || dataConfig.Symbol.Underlying == _twx))
-            {
-                throw new RegressionTestException($"Was NOT expecting any configurations for {_twx} or it's options, since we removed the contract");
-            }
-
-            if (SubscriptionManager.Subscriptions.All(dataConfig => dataConfig.Symbol != _aapl))
-            {
-                throw new RegressionTestException($"Was expecting configurations for {_aapl}");
-            }
-            if (SubscriptionManager.Subscriptions.All(dataConfig => dataConfig.Symbol.Underlying != _aapl))
-            {
-                throw new RegressionTestException($"Was expecting options configurations for {_aapl}");
-            }
-        }
-
-        /// <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 List<Language> Languages { get; } = new() { Language.CSharp, Language.Python };
-
-        /// <summary>
-        /// Data Points count of all timeslices of algorithm
-        /// </summary>
-        public long DataPoints => 5798;
-
-        /// <summary>
-        /// Data Points count of the algorithm history
-        /// </summary>
-        public int AlgorithmHistoryDataPoints => 2;
-
-        /// <summary>
-        /// Final status of the algorithm
-        /// </summary>
-        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
-
-        /// <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 Orders", "2"},
-            {"Average Win", "0%"},
-            {"Average Loss", "-0.23%"},
-            {"Compounding Annual Return", "-15.596%"},
-            {"Drawdown", "0.200%"},
-            {"Expectancy", "-1"},
-            {"Start Equity", "100000"},
-            {"End Equity", "99768"},
-            {"Net Profit", "-0.232%"},
-            {"Sharpe Ratio", "-8.903"},
-            {"Sortino Ratio", "0"},
-            {"Probabilistic Sharpe Ratio", "1.216%"},
-            {"Loss Rate", "100%"},
-            {"Win Rate", "0%"},
-            {"Profit-Loss Ratio", "0"},
-            {"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.335"},
-            {"Total Fees", "$2.00"},
-            {"Estimated Strategy Capacity", "$2800000.00"},
-            {"Lowest Capacity Asset", "AOL VRKS95ENLBYE|AOL R735QTJ8XC9X"},
-            {"Portfolio Turnover", "1.14%"},
-            {"OrderListHash", "cde7b518b7ad6d86cff6e5e092d9a413"}
-        };
-    }
-}

Algorithm.CSharp/AddOptionContractTwiceRegressionAlgorithm.cs

@@ -1,165 +0,0 @@
-/*
- * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
- * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
-*/
-
-using System;
-using System.Linq;
-using QuantConnect.Data;
-using QuantConnect.Interfaces;
-using System.Collections.Generic;
-
-namespace QuantConnect.Algorithm.CSharp
-{
-    /// <summary>
-    /// Regression algorithm reproducing GH issue #6073 where we remove and re add an option and expect it to work
-    /// </summary>
-    public class AddOptionContractTwiceRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
-    {
-        private Symbol _contract;
-        private bool _hasRemoved;
-        private bool _reAdded;
-
-        public override void Initialize()
-        {
-            SetStartDate(2014, 06, 06);
-            SetEndDate(2014, 06, 09);
-
-            UniverseSettings.DataNormalizationMode = DataNormalizationMode.Raw;
-            UniverseSettings.MinimumTimeInUniverse = TimeSpan.Zero;
-            UniverseSettings.FillForward = false;
-
-            AddEquity("SPY", Resolution.Hour);
-
-            var aapl = QuantConnect.Symbol.Create("AAPL", SecurityType.Equity, Market.USA);
-
-            _contract = OptionChain(aapl)
-                .OrderBy(x => x.ID.StrikePrice)
-                .FirstOrDefault(optionContract => optionContract.ID.OptionRight == OptionRight.Call
-                    && optionContract.ID.OptionStyle == OptionStyle.American);
-            AddOptionContract(_contract);
-        }
-
-        public override void OnData(Slice slice)
-        {
-            if (_hasRemoved)
-            {
-                if (!_reAdded && slice.ContainsKey(_contract) && slice.ContainsKey(_contract.Underlying))
-                {
-                    throw new RegressionTestException("Getting data for removed option and underlying!");
-                }
-
-                if (!Portfolio.Invested && _reAdded)
-                {
-                    var option = Securities[_contract];
-                    var optionUnderlying = Securities[_contract.Underlying];
-                    if (option.IsTradable && optionUnderlying.IsTradable
-                        && slice.ContainsKey(_contract) && slice.ContainsKey(_contract.Underlying))
-                    {
-                        Buy(_contract, 1);
-                    }
-                }
-
-                if (!Securities[_contract].IsTradable
-                    && !Securities[_contract.Underlying].IsTradable
-                    && !_reAdded)
-                {
-                    // ha changed my mind!
-                    AddOptionContract(_contract);
-                    _reAdded = true;
-                }
-            }
-
-            if (slice.ContainsKey(_contract) && slice.ContainsKey(_contract.Underlying))
-            {
-                if (!_hasRemoved)
-                {
-                    RemoveOptionContract(_contract);
-                    RemoveSecurity(_contract.Underlying);
-                    _hasRemoved = true;
-                }
-            }
-        }
-
-        public override void OnEndOfAlgorithm()
-        {
-            if (!_hasRemoved)
-            {
-                throw new RegressionTestException("We did not remove the option contract!");
-            }
-            if (!_reAdded)
-            {
-                throw new RegressionTestException("We did not re add the option contract!");
-            }
-        }
-
-        /// <summary>
-        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
-        /// </summary>
-        public bool CanRunLocally { get; } = true;
-
-        /// <summary>
-        /// This is used by the regression test system to indicate which languages this algorithm is written in.
-        /// </summary>
-        public List<Language> Languages { get; } = new() { Language.CSharp };
-
-        /// <summary>
-        /// Data Points count of all timeslices of algorithm
-        /// </summary>
-        public long DataPoints => 3814;
-
-        /// <summary>
-        /// Data Points count of the algorithm history
-        /// </summary>
-        public int AlgorithmHistoryDataPoints => 1;
-
-        /// <summary>
-        /// Final status of the algorithm
-        /// </summary>
-        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
-
-        /// <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 Orders", "2"},
-            {"Average Win", "0%"},
-            {"Average Loss", "-0.50%"},
-            {"Compounding Annual Return", "-39.406%"},
-            {"Drawdown", "0.700%"},
-            {"Expectancy", "-1"},
-            {"Start Equity", "100000"},
-            {"End Equity", "99498"},
-            {"Net Profit", "-0.502%"},
-            {"Sharpe Ratio", "0"},
-            {"Sortino Ratio", "0"},
-            {"Probabilistic Sharpe Ratio", "0%"},
-            {"Loss Rate", "100%"},
-            {"Win Rate", "0%"},
-            {"Profit-Loss Ratio", "0"},
-            {"Alpha", "0"},
-            {"Beta", "0"},
-            {"Annual Standard Deviation", "0"},
-            {"Annual Variance", "0"},
-            {"Information Ratio", "-9.486"},
-            {"Tracking Error", "0.008"},
-            {"Treynor Ratio", "0"},
-            {"Total Fees", "$2.00"},
-            {"Estimated Strategy Capacity", "$5000000.00"},
-            {"Lowest Capacity Asset", "AAPL VXBK4R62CXGM|AAPL R735QTJ8XC9X"},
-            {"Portfolio Turnover", "22.70%"},
-            {"OrderListHash", "29fd1b75f6db05dd823a6db7e8bd90a9"}
-        };
-    }
-}

Algorithm.CSharp/AddOptionWithOnMarketOpenOnlyFilterRegressionAlgorithm.cs

@@ -1,126 +0,0 @@
-/*
- * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
- * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
-*/
-
-using System.Collections.Generic;
-using System.Linq;
-using QuantConnect.Data.UniverseSelection;
-using QuantConnect.Interfaces;
-using QuantConnect.Securities;
-
-namespace QuantConnect.Algorithm.CSharp
-{
-    /// <summary>
-    /// Algorithm asserting that using OnlyApplyFilterAtMarketOpen along with other dynamic filters will make the filters be applied only on market
-    /// open, regardless of the order of configuration of the filters
-    /// </summary>
-    public class AddOptionWithOnMarketOpenOnlyFilterRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
-    {
-        public override void Initialize()
-        {
-            SetStartDate(2014, 6, 5);
-            SetEndDate(2014, 6, 10);
-
-            // OnlyApplyFilterAtMarketOpen as first filter
-            AddOption("AAPL", Resolution.Minute).SetFilter(u =>
-                u.OnlyApplyFilterAtMarketOpen()
-                 .Strikes(-5, 5)
-                 .Expiration(0, 100)
-                 .IncludeWeeklys());
-
-            // OnlyApplyFilterAtMarketOpen as last filter
-            AddOption("TWX", Resolution.Minute).SetFilter(u =>
-                u.Strikes(-5, 5)
-                 .Expiration(0, 100)
-                 .IncludeWeeklys()
-                 .OnlyApplyFilterAtMarketOpen());
-        }
-
-        public override void OnSecuritiesChanged(SecurityChanges changes)
-        {
-            // This will be the first call, the underlying securities are added.
-            if (changes.AddedSecurities.All(s => s.Type != SecurityType.Option))
-            {
-                return;
-            }
-
-            var changeOptions = changes.AddedSecurities.Concat(changes.RemovedSecurities)
-                                                                        .Where(s => s.Type == SecurityType.Option);
-
-            if (Time != Time.Date)
-            {
-                throw new RegressionTestException($"Expected options filter to be run only at midnight. Actual was {Time}");
-            }
-        }
-
-        /// <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 List<Language> Languages { get; } = new() { Language.CSharp };
-
-        /// <summary>
-        /// Data Points count of all time slices of algorithm
-        /// </summary>
-        public long DataPoints => 470217;
-
-        /// <summary>
-        /// Data Points count of the algorithm history
-        /// </summary>
-        public int AlgorithmHistoryDataPoints => 0;
-
-        /// <summary>
-        /// Final status of the algorithm
-        /// </summary>
-        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
-
-        /// <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 Orders", "0"},
-            {"Average Win", "0%"},
-            {"Average Loss", "0%"},
-            {"Compounding Annual Return", "0%"},
-            {"Drawdown", "0%"},
-            {"Expectancy", "0"},
-            {"Start Equity", "100000"},
-            {"End Equity", "100000"},
-            {"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", "-10.144"},
-            {"Tracking Error", "0.033"},
-            {"Treynor Ratio", "0"},
-            {"Total Fees", "$0.00"},
-            {"Estimated Strategy Capacity", "$0"},
-            {"Lowest Capacity Asset", ""},
-            {"Portfolio Turnover", "0%"},
-            {"OrderListHash", "d41d8cd98f00b204e9800998ecf8427e"}
-        };
-    }
-}

Algorithm.CSharp/AddRemoveOptionUniverseRegressionAlgorithm.cs

@@ -29,21 +29,20 @@ namespace QuantConnect.Algorithm.CSharp
     public class AddRemoveOptionUniverseRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
     {
         private const string UnderlyingTicker = "GOOG";
-        private readonly Symbol Underlying = QuantConnect.Symbol.Create(UnderlyingTicker, SecurityType.Equity, Market.USA);
-        private readonly Symbol OptionChainSymbol = QuantConnect.Symbol.Create(UnderlyingTicker, SecurityType.Option, Market.USA);
+        public readonly Symbol Underlying = QuantConnect.Symbol.Create(UnderlyingTicker, SecurityType.Equity, Market.USA);
+        public readonly Symbol OptionChainSymbol = QuantConnect.Symbol.Create(UnderlyingTicker, SecurityType.Option, Market.USA);
         private readonly HashSet<Symbol> _expectedSecurities = new HashSet<Symbol>();
         private readonly HashSet<Symbol> _expectedData = new HashSet<Symbol>();
         private readonly HashSet<Symbol> _expectedUniverses = new HashSet<Symbol>();
         private bool _expectUniverseSubscription;
-        private DateTime _universeSubscriptionTime;
 
         // order of expected contract additions as price moves
         private int _expectedContractIndex;
         private readonly List<Symbol> _expectedContracts = new List<Symbol>
         {
+            SymbolRepresentation.ParseOptionTickerOSI("GOOG  151224P00747500"),
             SymbolRepresentation.ParseOptionTickerOSI("GOOG  151224P00750000"),
-            SymbolRepresentation.ParseOptionTickerOSI("GOOG  151224P00752500"),
-            SymbolRepresentation.ParseOptionTickerOSI("GOOG  151224P00755000")
+            SymbolRepresentation.ParseOptionTickerOSI("GOOG  151224P00752500")
         };
 
         public override void Initialize()
@@ -60,16 +59,16 @@ namespace QuantConnect.Algorithm.CSharp
             _expectedUniverses.Add(UserDefinedUniverse.CreateSymbol(SecurityType.Equity, Market.USA));
         }
 
-        public override void OnData(Slice slice)
+        public override void OnData(Slice data)
         {
             // verify expectations
             if (SubscriptionManager.Subscriptions.Count(x => x.Symbol == OptionChainSymbol)
                 != (_expectUniverseSubscription ? 1 : 0))
             {
                 Log($"SubscriptionManager.Subscriptions:  {string.Join(" -- ", SubscriptionManager.Subscriptions)}");
-                throw new RegressionTestException($"Unexpected {OptionChainSymbol} subscription presence");
+                throw new Exception($"Unexpected {OptionChainSymbol} subscription presence");
             }
-            if (Time != _universeSubscriptionTime && !slice.ContainsKey(Underlying))
+            if (!data.ContainsKey(Underlying))
             {
                 // TODO : In fact, we're unable to properly detect whether or not we auto-added or it was manually added
                 // this is because when we auto-add the underlying we don't mark it as an internal security like we do with other auto adds
@@ -78,46 +77,41 @@ namespace QuantConnect.Algorithm.CSharp
                 // of the internal flag's purpose, so kicking this issue for now with a big fat note here about it :) to be considerd for any future
                 // refactorings of how we manage subscription/security data and track various aspects about the security (thinking a flags enum with
                 // things like manually added, auto added, internal, and any other boolean state we need to track against a single security)
-                throw new RegressionTestException("The underlying equity data should NEVER be removed in this algorithm because it was manually added");
+                throw new Exception("The underlying equity data should NEVER be removed in this algorithm because it was manually added");
             }
-            if (_expectedSecurities.AreDifferent(Securities.Total.Select(x => x.Symbol).ToHashSet()))
+            if (_expectedSecurities.AreDifferent(LinqExtensions.ToHashSet(Securities.Keys)))
             {
                 var expected = string.Join(Environment.NewLine, _expectedSecurities.OrderBy(s => s.ToString()));
                 var actual = string.Join(Environment.NewLine, Securities.Keys.OrderBy(s => s.ToString()));
-                throw new RegressionTestException($"{Time}:: Detected differences in expected and actual securities{Environment.NewLine}Expected:{Environment.NewLine}{expected}{Environment.NewLine}Actual:{Environment.NewLine}{actual}");
+                throw new Exception($"{Time}:: Detected differences in expected and actual securities{Environment.NewLine}Expected:{Environment.NewLine}{expected}{Environment.NewLine}Actual:{Environment.NewLine}{actual}");
             }
-            if (_expectedUniverses.AreDifferent(UniverseManager.Keys.ToHashSet()))
+            if (_expectedUniverses.AreDifferent(LinqExtensions.ToHashSet(UniverseManager.Keys)))
             {
                 var expected = string.Join(Environment.NewLine, _expectedUniverses.OrderBy(s => s.ToString()));
                 var actual = string.Join(Environment.NewLine, UniverseManager.Keys.OrderBy(s => s.ToString()));
-                throw new RegressionTestException($"{Time}:: Detected differences in expected and actual universes{Environment.NewLine}Expected:{Environment.NewLine}{expected}{Environment.NewLine}Actual:{Environment.NewLine}{actual}");
+                throw new Exception($"{Time}:: Detected differences in expected and actual universes{Environment.NewLine}Expected:{Environment.NewLine}{expected}{Environment.NewLine}Actual:{Environment.NewLine}{actual}");
             }
-            if (Time != _universeSubscriptionTime && _expectedData.AreDifferent(slice.Keys.ToHashSet()))
+            if (_expectedData.AreDifferent(LinqExtensions.ToHashSet(data.Keys)))
             {
                 var expected = string.Join(Environment.NewLine, _expectedData.OrderBy(s => s.ToString()));
-                var actual = string.Join(Environment.NewLine, slice.Keys.OrderBy(s => s.ToString()));
-                throw new RegressionTestException($"{Time}:: Detected differences in expected and actual slice data keys{Environment.NewLine}Expected:{Environment.NewLine}{expected}{Environment.NewLine}Actual:{Environment.NewLine}{actual}");
+                var actual = string.Join(Environment.NewLine, data.Keys.OrderBy(s => s.ToString()));
+                throw new Exception($"{Time}:: Detected differences in expected and actual slice data keys{Environment.NewLine}Expected:{Environment.NewLine}{expected}{Environment.NewLine}Actual:{Environment.NewLine}{actual}");
             }
 
             // 10AM add GOOG option chain
-            if (Time.TimeOfDay.Hours == 10 && Time.TimeOfDay.Minutes == 0 && !_expectUniverseSubscription)
+            if (Time.TimeOfDay.Hours == 10 && Time.TimeOfDay.Minutes == 0)
             {
                 if (Securities.ContainsKey(OptionChainSymbol))
                 {
-                    throw new RegressionTestException("The option chain security should not have been added yet");
+                    throw new Exception("The option chain security should not have been added yet");
                 }
 
                 var googOptionChain = AddOption(UnderlyingTicker);
                 googOptionChain.SetFilter(u =>
                 {
-                    // we added the universe at 10, the universe selection data should not be from before
-                    if (u.LocalTime.Hour < 10)
-                    {
-                        throw new RegressionTestException($"Unexpected selection time {u.LocalTime}");
-                    }
                     // find first put above market price
                     return u.IncludeWeeklys()
-                        .Strikes(+1, +3)
+                        .Strikes(+1, +1)
                         .Expiration(TimeSpan.Zero, TimeSpan.FromDays(1))
                         .Contracts(c => c.Where(s => s.ID.OptionRight == OptionRight.Put));
                 });
@@ -125,7 +119,6 @@ namespace QuantConnect.Algorithm.CSharp
                 _expectedSecurities.Add(OptionChainSymbol);
                 _expectedUniverses.Add(OptionChainSymbol);
                 _expectUniverseSubscription = true;
-                _universeSubscriptionTime = Time;
             }
 
             // 11:30AM remove GOOG option chain
@@ -143,6 +136,16 @@ 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)
@@ -153,7 +156,7 @@ namespace QuantConnect.Algorithm.CSharp
                         var expectedContract = _expectedContracts[_expectedContractIndex];
                         if (added.Symbol != expectedContract)
                         {
-                            throw new RegressionTestException($"Expected option contract {expectedContract.Value} to be added but received {added.Symbol}");
+                            throw new Exception($"Expected option contract {expectedContract} to be added but received {added.Symbol}");
                         }
 
                         _expectedContractIndex++;
@@ -174,21 +177,21 @@ namespace QuantConnect.Algorithm.CSharp
                 // receive removed event next timestep at 11:31AM
                 if (Time.TimeOfDay.Hours != 11 || Time.TimeOfDay.Minutes != 31)
                 {
-                    throw new RegressionTestException($"Expected option contracts to be removed at 11:31AM, instead removed at: {Time}");
+                    throw new Exception($"Expected option contracts to be removed at 11:31AM, instead removed at: {Time}");
                 }
 
                 if (changes.RemovedSecurities
                     .Where(x => x.Symbol.SecurityType == SecurityType.Option)
                     .ToHashSet(s => s.Symbol)
-                    .AreDifferent(_expectedContracts.ToHashSet()))
+                    .AreDifferent(LinqExtensions.ToHashSet(_expectedContracts)))
                 {
-                    throw new RegressionTestException("Expected removed securities to equal expected contracts added");
+                    throw new Exception("Expected removed securities to equal expected contracts added");
                 }
             }
 
             if (Securities.ContainsKey(Underlying))
             {
-                Log($"{Time:o}:: PRICE:: {Securities[Underlying].Price} CHANGES:: {changes}");
+                Console.WriteLine($"{Time:o}:: PRICE:: {Securities[Underlying].Price} CHANGES:: {changes}");
             }
         }
 
@@ -200,41 +203,22 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// This is used by the regression test system to indicate which languages this algorithm is written in.
         /// </summary>
-        public List<Language> Languages { get; } = new() { Language.CSharp };
-
-        /// <summary>
-        /// Data Points count of all timeslices of algorithm
-        /// </summary>
-        public long DataPoints => 3502;
-
-        /// <summary>
-        /// Data Points count of the algorithm history
-        /// </summary>
-        public int AlgorithmHistoryDataPoints => 0;
-
-        /// <summary>
-        /// Final status of the algorithm
-        /// </summary>
-        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
+        public Language[] Languages { get; } = { Language.CSharp };
 
         /// <summary>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
         /// </summary>
         public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
-            {"Total Orders", "6"},
+            {"Total Trades", "6"},
             {"Average Win", "0%"},
-            {"Average Loss", "0%"},
-            {"Compounding Annual Return", "0%"},
-            {"Drawdown", "0%"},
-            {"Expectancy", "0"},
-            {"Start Equity", "100000"},
-            {"End Equity", "98784"},
-            {"Net Profit", "0%"},
+            {"Average Loss", "-0.21%"},
+            {"Compounding Annual Return", "-98.595%"},
+            {"Drawdown", "0.600%"},
+            {"Expectancy", "-1"},
+            {"Net Profit", "-0.631%"},
             {"Sharpe Ratio", "0"},
-            {"Sortino Ratio", "0"},
-            {"Probabilistic Sharpe Ratio", "0%"},
-            {"Loss Rate", "0%"},
+            {"Loss Rate", "100%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
             {"Alpha", "0"},
@@ -244,11 +228,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Information Ratio", "0"},
             {"Tracking Error", "0"},
             {"Treynor Ratio", "0"},
-            {"Total Fees", "$6.00"},
-            {"Estimated Strategy Capacity", "$4000.00"},
-            {"Lowest Capacity Asset", "GOOCV 305RBQ2BZBZT2|GOOCV VP83T1ZUHROL"},
-            {"Portfolio Turnover", "2.58%"},
-            {"OrderListHash", "09f766c470a8bcf4bb6862da52bf25a7"}
+            {"Total Fees", "$6.00"}
         };
     }
 }

Algorithm.CSharp/AddRemoveSecurityCacheRegressionAlgorithm.cs

@@ -1,132 +0,0 @@
-/*
- * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
- * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
-*/
-
-using System;
-using QuantConnect.Data;
-using QuantConnect.Interfaces;
-using System.Collections.Generic;
-using QuantConnect.Orders;
-
-namespace QuantConnect.Algorithm.CSharp
-{
-    /// <summary>
-    /// Regression algorithm making sure the securities cache is reset correctly once it's removed from the algorithm
-    /// </summary>
-    public class AddRemoveSecurityCacheRegressionAlgorithm : 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);  //Set Start Date
-            SetEndDate(2013, 10, 11);    //Set End Date
-            SetCash(100000);             //Set Strategy Cash
-
-            AddEquity("SPY", Resolution.Minute, extendedMarketHours: true);
-        }
-
-        /// <summary>
-        /// OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here.
-        /// </summary>
-        /// <param name="slice">Slice object keyed by symbol containing the stock data</param>
-        public override void OnData(Slice slice)
-        {
-            if (!Portfolio.Invested)
-            {
-                SetHoldings("SPY", 1);
-            }
-
-            if (Time.Day == 11)
-            {
-                return;
-            }
-            if (!ActiveSecurities.ContainsKey("AIG"))
-            {
-                var aig = AddEquity("AIG", Resolution.Minute);
-
-                var ticket = MarketOrder("AIG", 1);
-
-                if (ticket.Status != OrderStatus.Invalid)
-                {
-                    throw new RegressionTestException("Expected order to always be invalid because there is no data yet!");
-                }
-            }
-            else
-            {
-                RemoveSecurity("AIG");
-            }
-        }
-
-        /// <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 List<Language> Languages { get; } = new() { Language.CSharp };
-
-        /// <summary>
-        /// Data Points count of all timeslices of algorithm
-        /// </summary>
-        public long DataPoints => 11202;
-
-        /// <summary>
-        /// Data Points count of the algorithm history
-        /// </summary>
-        public int AlgorithmHistoryDataPoints => 0;
-
-        /// <summary>
-        /// Final status of the algorithm
-        /// </summary>
-        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
-
-        /// <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 Orders", "19"},
-            {"Average Win", "0%"},
-            {"Average Loss", "0.00%"},
-            {"Compounding Annual Return", "271.720%"},
-            {"Drawdown", "2.500%"},
-            {"Expectancy", "-1"},
-            {"Start Equity", "100000"},
-            {"End Equity", "101753.84"},
-            {"Net Profit", "1.754%"},
-            {"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.616"},
-            {"Beta", "0.81"},
-            {"Annual Standard Deviation", "0.185"},
-            {"Annual Variance", "0.034"},
-            {"Information Ratio", "3.961"},
-            {"Tracking Error", "0.061"},
-            {"Treynor Ratio", "2.737"},
-            {"Total Fees", "$21.45"},
-            {"Estimated Strategy Capacity", "$830000.00"},
-            {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
-            {"Portfolio Turnover", "20.49%"},
-            {"OrderListHash", "6ebe462373e2ecc22de8eb2fe114d704"}
-        };
-    }
-}

Algorithm.CSharp/AddRemoveSecurityRegressionAlgorithm.cs

@@ -18,7 +18,6 @@ using System.Collections.Generic;
 using QuantConnect.Data.Market;
 using QuantConnect.Orders;
 using QuantConnect.Interfaces;
-using QuantConnect.Data;
 
 namespace QuantConnect.Algorithm.CSharp
 {
@@ -52,7 +51,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// 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 slice)
+        public void OnData(TradeBars data)
         {
             if (lastAction.Date == Time.Date) return;
 
@@ -75,8 +74,8 @@ namespace QuantConnect.Algorithm.CSharp
             }
             else if (Time.DayOfWeek == DayOfWeek.Thursday)
             {
-                RemoveSecurity(_aig);
                 RemoveSecurity(_bac);
+                RemoveSecurity(_aig);
                 lastAction = Time;
             }
         }
@@ -105,55 +104,32 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// This is used by the regression test system to indicate which languages this algorithm is written in.
         /// </summary>
-        public List<Language> Languages { get; } = new() { Language.CSharp, Language.Python };
-
-        /// <summary>
-        /// Data Points count of all timeslices of algorithm
-        /// </summary>
-        public long DataPoints => 7063;
-
-        /// <summary>
-        /// Data Points count of the algorithm history
-        /// </summary>
-        public int AlgorithmHistoryDataPoints => 0;
-
-        /// <summary>
-        /// Final status of the algorithm
-        /// </summary>
-        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
+        public Language[] Languages { get; } = { Language.CSharp, Language.Python };
 
         /// <summary>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
         /// </summary>
         public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
-            {"Total Orders", "5"},
-            {"Average Win", "0.46%"},
+            {"Total Trades", "5"},
+            {"Average Win", "0.49%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "296.356%"},
+            {"Compounding Annual Return", "305.340%"},
             {"Drawdown", "1.400%"},
             {"Expectancy", "0"},
-            {"Start Equity", "100000"},
-            {"End Equity", "101776.32"},
-            {"Net Profit", "1.776%"},
-            {"Sharpe Ratio", "12.966"},
-            {"Sortino Ratio", "0"},
-            {"Probabilistic Sharpe Ratio", "80.409%"},
+            {"Net Profit", "1.805%"},
+            {"Sharpe Ratio", "6.475"},
             {"Loss Rate", "0%"},
             {"Win Rate", "100%"},
             {"Profit-Loss Ratio", "0"},
-            {"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.935"},
-            {"Total Fees", "$28.30"},
-            {"Estimated Strategy Capacity", "$4700000.00"},
-            {"Lowest Capacity Asset", "AIG R735QTJ8XC9X"},
-            {"Portfolio Turnover", "29.88%"},
-            {"OrderListHash", "6061ecfbb89eb365dff913410d279b7c"}
+            {"Alpha", "0.003"},
+            {"Beta", "82.247"},
+            {"Annual Standard Deviation", "0.141"},
+            {"Annual Variance", "0.02"},
+            {"Information Ratio", "6.401"},
+            {"Tracking Error", "0.141"},
+            {"Treynor Ratio", "0.011"},
+            {"Total Fees", "$26.40"}
         };
     }
 }

Algorithm.CSharp/AddRiskManagementAlgorithm.cs

@@ -1,4 +1,4 @@
-/*
+/*
  * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
  * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
  *
@@ -57,55 +57,45 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// This is used by the regression test system to indicate which languages this algorithm is written in.
         /// </summary>
-        public List<Language> Languages { get; } = new() { Language.CSharp, Language.Python };
-
-        /// <summary>
-        /// Data Points count of all timeslices of algorithm
-        /// </summary>
-        public long DataPoints => 3943;
-
-        /// <summary>
-        /// Data Points count of the algorithm history
-        /// </summary>
-        public int AlgorithmHistoryDataPoints => 0;
-
-        /// <summary>
-        /// Final status of the algorithm
-        /// </summary>
-        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
+        public Language[] Languages { get; } = { Language.CSharp, Language.Python };
 
         /// <summary>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
         /// </summary>
         public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
-            {"Total Orders", "3"},
+            {"Total Trades", "3"},
             {"Average Win", "1.02%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "296.066%"},
+            {"Compounding Annual Return", "289.117%"},
             {"Drawdown", "2.200%"},
             {"Expectancy", "0"},
-            {"Start Equity", "100000"},
-            {"End Equity", "101775.37"},
-            {"Net Profit", "1.775%"},
-            {"Sharpe Ratio", "9.34"},
-            {"Sortino Ratio", "0"},
-            {"Probabilistic Sharpe Ratio", "68.302%"},
+            {"Net Profit", "1.752%"},
+            {"Sharpe Ratio", "4.52"},
             {"Loss Rate", "0%"},
             {"Win Rate", "100%"},
             {"Profit-Loss Ratio", "0"},
-            {"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.079"},
-            {"Total Fees", "$10.33"},
-            {"Estimated Strategy Capacity", "$38000000.00"},
-            {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
-            {"Portfolio Turnover", "59.74%"},
-            {"OrderListHash", "5d7657ec9954875eca633bed711085d3"}
+            {"Alpha", "0.007"},
+            {"Beta", "80.237"},
+            {"Annual Standard Deviation", "0.197"},
+            {"Annual Variance", "0.039"},
+            {"Information Ratio", "4.466"},
+            {"Tracking Error", "0.197"},
+            {"Treynor Ratio", "0.011"},
+            {"Total Fees", "$9.77"},
+            {"Total Insights Generated", "100"},
+            {"Total Insights Closed", "99"},
+            {"Total Insights Analysis Completed", "99"},
+            {"Long Insight Count", "100"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "$158418.3850"},
+            {"Total Accumulated Estimated Alpha Value", "$25522.9620"},
+            {"Mean Population Estimated Insight Value", "$257.8077"},
+            {"Mean Population Direction", "54.5455%"},
+            {"Mean Population Magnitude", "54.5455%"},
+            {"Rolling Averaged Population Direction", "59.8056%"},
+            {"Rolling Averaged Population Magnitude", "59.8056%"}
         };
     }
 }

Algorithm.CSharp/AddTwoAndRemoveOneOptionContractRegressionAlgorithm.cs

@@ -1,150 +0,0 @@
-/*
- * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
- * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
-*/
-
-using System;
-using System.Linq;
-using QuantConnect.Data;
-using QuantConnect.Interfaces;
-using System.Collections.Generic;
-
-namespace QuantConnect.Algorithm.CSharp
-{
-    /// <summary>
-    /// Regression algorithm reproducing issue where underlying option contract would be removed with the first call
-    /// too RemoveOptionContract
-    /// </summary>
-    public class AddTwoAndRemoveOneOptionContractRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
-    {
-        private Symbol _contract1;
-        private Symbol _contract2;
-        private bool _hasRemoved;
-
-        public override void Initialize()
-        {
-            SetStartDate(2014, 06, 06);
-            SetEndDate(2014, 06, 06);
-
-            UniverseSettings.DataNormalizationMode = DataNormalizationMode.Raw;
-            UniverseSettings.MinimumTimeInUniverse = TimeSpan.Zero;
-
-            var aapl = QuantConnect.Symbol.Create("AAPL", SecurityType.Equity, Market.USA);
-
-            var contracts = OptionChain(aapl)
-                .OrderBy(x => x.ID.StrikePrice)
-                .Where(optionContract => optionContract.ID.OptionRight == OptionRight.Call
-                    && optionContract.ID.OptionStyle == OptionStyle.American)
-                .Take(2)
-                .ToList();
-
-            _contract1 = contracts[0];
-            _contract2 = contracts[1];
-            AddOptionContract(_contract1);
-            AddOptionContract(_contract2);
-        }
-
-        public override void OnData(Slice slice)
-        {
-            if (slice.HasData)
-            {
-                if (!_hasRemoved)
-                {
-                    RemoveOptionContract(_contract1);
-                    _hasRemoved = true;
-                }
-                else
-                {
-                    var subscriptions =
-                        SubscriptionManager.SubscriptionDataConfigService.GetSubscriptionDataConfigs("AAPL");
-                    if (subscriptions.Count == 0)
-                    {
-                        throw new RegressionTestException("No configuration for underlying was found!");
-                    }
-
-                    if (!Portfolio.Invested)
-                    {
-                        Buy(_contract2, 1);
-                    }
-                }
-            }
-        }
-
-        public override void OnEndOfAlgorithm()
-        {
-            if (!_hasRemoved)
-            {
-                throw new RegressionTestException("Expect a single call to OnData where we removed the option and underlying");
-            }
-        }
-
-        /// <summary>
-        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
-        /// </summary>
-        public bool CanRunLocally { get; } = true;
-
-        /// <summary>
-        /// This is used by the regression test system to indicate which languages this algorithm is written in.
-        /// </summary>
-        public List<Language> Languages { get; } = new() { Language.CSharp };
-
-        /// <summary>
-        /// Data Points count of all timeslices of algorithm
-        /// </summary>
-        public long DataPoints => 1578;
-
-        /// <summary>
-        /// Data Points count of the algorithm history
-        /// </summary>
-        public int AlgorithmHistoryDataPoints => 1;
-
-        /// <summary>
-        /// Final status of the algorithm
-        /// </summary>
-        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
-
-        /// <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 Orders", "2"},
-            {"Average Win", "0%"},
-            {"Average Loss", "0%"},
-            {"Compounding Annual Return", "0%"},
-            {"Drawdown", "0%"},
-            {"Expectancy", "0"},
-            {"Start Equity", "100000"},
-            {"End Equity", "99238"},
-            {"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", "$2.00"},
-            {"Estimated Strategy Capacity", "$6200000.00"},
-            {"Lowest Capacity Asset", "AAPL VXBK4QA5EM92|AAPL R735QTJ8XC9X"},
-            {"Portfolio Turnover", "90.27%"},
-            {"OrderListHash", "a111609c2c64554268539b5798e5b31f"}
-        };
-    }
-}

Algorithm.CSharp/AddUniverseSelectionModelAlgorithm.cs

@@ -1,4 +1,4 @@
-/*
+/*
  * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
  * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
  *
@@ -57,14 +57,14 @@ namespace QuantConnect.Algorithm.CSharp
         {
             if (UniverseManager.Count != 3)
             {
-                throw new RegressionTestException("Unexpected universe count");
+                throw new Exception("Unexpected universe count");
             }
             if (UniverseManager.ActiveSecurities.Count != 3
                 || UniverseManager.ActiveSecurities.Keys.All(symbol => symbol.Value != "SPY")
                 || UniverseManager.ActiveSecurities.Keys.All(symbol => symbol.Value != "AAPL")
                 || UniverseManager.ActiveSecurities.Keys.All(symbol => symbol.Value != "FB"))
             {
-                throw new RegressionTestException("Unexpected active securities");
+                throw new Exception("Unexpected active securities");
             }
         }
 
@@ -76,55 +76,45 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// This is used by the regression test system to indicate which languages this algorithm is written in.
         /// </summary>
-        public List<Language> Languages { get; } = new() { Language.CSharp, Language.Python };
-
-        /// <summary>
-        /// Data Points count of all timeslices of algorithm
-        /// </summary>
-        public long DataPoints => 50;
-
-        /// <summary>
-        /// Data Points count of the algorithm history
-        /// </summary>
-        public int AlgorithmHistoryDataPoints => 0;
-
-        /// <summary>
-        /// Final status of the algorithm
-        /// </summary>
-        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
+        public Language[] Languages { get; } = { Language.CSharp, Language.Python };
 
         /// <summary>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
         /// </summary>
         public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
-            {"Total Orders", "6"},
-            {"Average Win", "0.01%"},
-            {"Average Loss", "0%"},
-            {"Compounding Annual Return", "1296.838%"},
-            {"Drawdown", "0.400%"},
-            {"Expectancy", "0"},
-            {"Start Equity", "100000"},
-            {"End Equity", "102684.23"},
-            {"Net Profit", "2.684%"},
-            {"Sharpe Ratio", "34.319"},
-            {"Sortino Ratio", "0"},
-            {"Probabilistic Sharpe Ratio", "0%"},
-            {"Loss Rate", "0%"},
-            {"Win Rate", "100%"},
+            {"Total Trades", "10"},
+            {"Average Win", "0%"},
+            {"Average Loss", "-0.01%"},
+            {"Compounding Annual Return", "-14.943%"},
+            {"Drawdown", "3.300%"},
+            {"Expectancy", "-1"},
+            {"Net Profit", "-0.177%"},
+            {"Sharpe Ratio", "-0.136"},
+            {"Loss Rate", "100%"},
+            {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "-5.738"},
-            {"Beta", "1.381"},
-            {"Annual Standard Deviation", "0.246"},
-            {"Annual Variance", "0.06"},
-            {"Information Ratio", "-26.937"},
-            {"Tracking Error", "0.068"},
-            {"Treynor Ratio", "6.106"},
-            {"Total Fees", "$18.61"},
-            {"Estimated Strategy Capacity", "$980000000.00"},
-            {"Lowest Capacity Asset", "FB V6OIPNZEM8V9"},
-            {"Portfolio Turnover", "25.56%"},
-            {"OrderListHash", "5ee20c8556d706ab0a63ae41b6579c62"}
+            {"Alpha", "0"},
+            {"Beta", "-4.084"},
+            {"Annual Standard Deviation", "0.332"},
+            {"Annual Variance", "0.11"},
+            {"Information Ratio", "-0.169"},
+            {"Tracking Error", "0.332"},
+            {"Treynor Ratio", "0.011"},
+            {"Total Fees", "$13.98"},
+            {"Total Insights Generated", "15"},
+            {"Total Insights Closed", "12"},
+            {"Total Insights Analysis Completed", "12"},
+            {"Long Insight Count", "15"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "$33015795.7342"},
+            {"Total Accumulated Estimated Alpha Value", "$4585527.1853"},
+            {"Mean Population Estimated Insight Value", "$382127.2654"},
+            {"Mean Population Direction", "66.6667%"},
+            {"Mean Population Magnitude", "66.6667%"},
+            {"Rolling Averaged Population Direction", "34.3681%"},
+            {"Rolling Averaged Population Magnitude", "34.3681%"}
         };
     }
 }

Algorithm.CSharp/AddUniverseSelectionModelCoarseAlgorithm.cs

@@ -1,4 +1,4 @@
-/*
+/*
  * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
  * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
  *
@@ -37,10 +37,6 @@ namespace QuantConnect.Algorithm.CSharp
             // Set requested data resolution
             UniverseSettings.Resolution = Resolution.Daily;
 
-            // Order margin value has to have a minimum of 0.5% of Portfolio value, allows filtering out small trades and reduce fees.
-            // Commented so regression algorithm is more sensitive
-            //Settings.MinimumOrderMarginPortfolioPercentage = 0.005m;
-
             SetStartDate(2014, 03, 24);
             SetEndDate(2014, 04, 07);
             SetCash(100000);
@@ -68,14 +64,14 @@ namespace QuantConnect.Algorithm.CSharp
         {
             if (UniverseManager.Count != 3)
             {
-                throw new RegressionTestException("Unexpected universe count");
+                throw new Exception("Unexpected universe count");
             }
             if (UniverseManager.ActiveSecurities.Count != 3
                 || UniverseManager.ActiveSecurities.Keys.All(symbol => symbol.Value != "SPY")
                 || UniverseManager.ActiveSecurities.Keys.All(symbol => symbol.Value != "AAPL")
                 || UniverseManager.ActiveSecurities.Keys.All(symbol => symbol.Value != "FB"))
             {
-                throw new RegressionTestException("Unexpected active securities");
+                throw new Exception("Unexpected active securities");
             }
         }
 
@@ -87,55 +83,45 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// This is used by the regression test system to indicate which languages this algorithm is written in.
         /// </summary>
-        public List<Language> Languages { get; } = new() { Language.CSharp };
-
-        /// <summary>
-        /// Data Points count of all timeslices of algorithm
-        /// </summary>
-        public long DataPoints => 234015;
-
-        /// <summary>
-        /// Data Points count of the algorithm history
-        /// </summary>
-        public int AlgorithmHistoryDataPoints => 0;
-
-        /// <summary>
-        /// Final status of the algorithm
-        /// </summary>
-        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
+        public Language[] Languages { get; } = { Language.CSharp };
 
         /// <summary>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
         /// </summary>
         public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
-            {"Total Orders", "21"},
-            {"Average Win", "0.01%"},
+            {"Total Trades", "23"},
+            {"Average Win", "0.00%"},
             {"Average Loss", "-0.01%"},
-            {"Compounding Annual Return", "-77.566%"},
-            {"Drawdown", "6.000%"},
-            {"Expectancy", "-0.811"},
-            {"Start Equity", "100000"},
-            {"End Equity", "94042.73"},
-            {"Net Profit", "-5.957%"},
-            {"Sharpe Ratio", "-3.345"},
-            {"Sortino Ratio", "-3.766"},
-            {"Probabilistic Sharpe Ratio", "4.557%"},
-            {"Loss Rate", "89%"},
-            {"Win Rate", "11%"},
+            {"Compounding Annual Return", "-75.360%"},
+            {"Drawdown", "5.800%"},
+            {"Expectancy", "-0.859"},
+            {"Net Profit", "-5.594%"},
+            {"Sharpe Ratio", "-5.582"},
+            {"Loss Rate", "92%"},
+            {"Win Rate", "8%"},
             {"Profit-Loss Ratio", "0.70"},
-            {"Alpha", "-0.519"},
-            {"Beta", "1.491"},
-            {"Annual Standard Deviation", "0.2"},
-            {"Annual Variance", "0.04"},
-            {"Information Ratio", "-3.878"},
-            {"Tracking Error", "0.147"},
-            {"Treynor Ratio", "-0.449"},
-            {"Total Fees", "$29.11"},
-            {"Estimated Strategy Capacity", "$680000000.00"},
-            {"Lowest Capacity Asset", "AAPL R735QTJ8XC9X"},
-            {"Portfolio Turnover", "7.48%"},
-            {"OrderListHash", "2c814c55e7d7c56482411c065b861b33"}
+            {"Alpha", "-1.454"},
+            {"Beta", "15.578"},
+            {"Annual Standard Deviation", "0.212"},
+            {"Annual Variance", "0.045"},
+            {"Information Ratio", "-5.664"},
+            {"Tracking Error", "0.212"},
+            {"Treynor Ratio", "-0.076"},
+            {"Total Fees", "$25.92"},
+            {"Total Insights Generated", "33"},
+            {"Total Insights Closed", "30"},
+            {"Total Insights Analysis Completed", "30"},
+            {"Long Insight Count", "33"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "$-7788114"},
+            {"Total Accumulated Estimated Alpha Value", "$-3937325"},
+            {"Mean Population Estimated Insight Value", "$-131244.2"},
+            {"Mean Population Direction", "46.6667%"},
+            {"Mean Population Magnitude", "46.6667%"},
+            {"Rolling Averaged Population Direction", "61.4247%"},
+            {"Rolling Averaged Population Magnitude", "61.4247%"}
         };
     }
 }

Algorithm.CSharp/AdjustedVolumeRegressionAlgorithm.cs

@@ -1,205 +0,0 @@
-/*
- * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
- * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
-*/
-
-using System;
-using System.Collections.Generic;
-using QuantConnect.Configuration;
-using QuantConnect.Data;
-using QuantConnect.Data.Auxiliary;
-using QuantConnect.Interfaces;
-using QuantConnect.Util;
-
-namespace QuantConnect.Algorithm.CSharp
-{
-    /// <summary>
-    /// Regression algorithm to test volume adjusted behavior
-    /// </summary>
-    public class AdjustedVolumeRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
-    {
-        private Symbol _aapl;
-        private const string Ticker = "AAPL";
-        private CorporateFactorProvider _factorFile;
-        private readonly IEnumerator<decimal> _expectedAdjustedVolume = new List<decimal> { 6164842, 3044047, 3680347, 3468303, 2169943, 2652523,
-            1499707, 1518215, 1655219, 1510487 }.GetEnumerator();
-        private readonly IEnumerator<decimal> _expectedAdjustedAskSize = new List<decimal> { 215600, 5600, 25200, 8400, 5600, 5600, 2800,
-            8400, 14000, 2800 }.GetEnumerator();
-        private readonly IEnumerator<decimal> _expectedAdjustedBidSize = new List<decimal> { 2800, 11200, 2800, 2800, 2800, 5600, 11200,
-            8400, 30800, 2800 }.GetEnumerator();
-
-        public override void Initialize()
-        {
-            SetStartDate(2014, 6, 5);      //Set Start Date
-            SetEndDate(2014, 6, 5);         //Set End Date
-
-            UniverseSettings.DataNormalizationMode = DataNormalizationMode.SplitAdjusted;
-            _aapl = AddEquity(Ticker, Resolution.Minute).Symbol;
-
-            var dataProvider =
-                Composer.Instance.GetExportedValueByTypeName<IDataProvider>(Config.Get("data-provider",
-                    "DefaultDataProvider"));
-
-            var mapFileProvider = new LocalDiskMapFileProvider();
-            mapFileProvider.Initialize(dataProvider);
-            var factorFileProvider = new LocalDiskFactorFileProvider();
-            factorFileProvider.Initialize(mapFileProvider, dataProvider);
-
-
-            _factorFile = factorFileProvider.Get(_aapl) as CorporateFactorProvider;
-        }
-
-        /// <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 slice)
-        {
-            if (!Portfolio.Invested)
-            {
-                SetHoldings(_aapl, 1);
-            }
-
-            if (slice.Splits.ContainsKey(_aapl))
-            {
-                Log(slice.Splits[_aapl].ToString());
-            }
-
-            if (slice.Bars.ContainsKey(_aapl))
-            {
-                var aaplData = slice.Bars[_aapl];
-
-                // Assert our volume matches what we expect
-                if (_expectedAdjustedVolume.MoveNext() && _expectedAdjustedVolume.Current != aaplData.Volume)
-                {
-                    // Our values don't match lets try and give a reason why
-                    var dayFactor = _factorFile.GetPriceScale(aaplData.Time, DataNormalizationMode.SplitAdjusted);
-                    var probableAdjustedVolume = aaplData.Volume / dayFactor;
-
-                    if (_expectedAdjustedVolume.Current == probableAdjustedVolume)
-                    {
-                        throw new ArgumentException($"Volume was incorrect; but manually adjusted value is correct." + 
-                            $" Adjustment by multiplying volume by {1 / dayFactor} is not occurring.");
-                    }
-                    else
-                    {
-                        throw new ArgumentException($"Volume was incorrect; even when adjusted manually by" + 
-                            $" multiplying volume by {1 / dayFactor}. Data may have changed.");
-                    }
-                }
-            }
-
-            if (slice.QuoteBars.ContainsKey(_aapl))
-            {
-                var aaplQuoteData = slice.QuoteBars[_aapl];
-
-                // Assert our askSize matches what we expect
-                if (_expectedAdjustedAskSize.MoveNext() && _expectedAdjustedAskSize.Current != aaplQuoteData.LastAskSize)
-                {
-                    // Our values don't match lets try and give a reason why
-                    var dayFactor = _factorFile.GetPriceScale(aaplQuoteData.Time, DataNormalizationMode.SplitAdjusted);
-                    var probableAdjustedAskSize = aaplQuoteData.LastAskSize / dayFactor;
-
-                    if (_expectedAdjustedAskSize.Current == probableAdjustedAskSize)
-                    {
-                        throw new ArgumentException($"Ask size was incorrect; but manually adjusted value is correct." +
-                            $" Adjustment by multiplying size by {1 / dayFactor} is not occurring.");
-                    }
-                    else
-                    {
-                        throw new ArgumentException($"Ask size was incorrect; even when adjusted manually by" +
-                            $" multiplying size by {1 / dayFactor}. Data may have changed.");
-                    }
-                }
-
-                // Assert our bidSize matches what we expect
-                if (_expectedAdjustedBidSize.MoveNext() && _expectedAdjustedBidSize.Current != aaplQuoteData.LastBidSize)
-                {
-                    // Our values don't match lets try and give a reason why
-                    var dayFactor = _factorFile.GetPriceScale(aaplQuoteData.Time, DataNormalizationMode.SplitAdjusted);
-                    var probableAdjustedBidSize = aaplQuoteData.LastBidSize / dayFactor;
-
-                    if (_expectedAdjustedBidSize.Current == probableAdjustedBidSize)
-                    {
-                        throw new ArgumentException($"Bid size was incorrect; but manually adjusted value is correct." +
-                            $" Adjustment by multiplying size by {1 / dayFactor} is not occurring.");
-                    }
-                    else
-                    {
-                        throw new ArgumentException($"Bid size was incorrect; even when adjusted manually by" +
-                            $" multiplying size by {1 / dayFactor}. Data may have changed.");
-                    }
-                }
-            }
-        }
-
-        /// <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 List<Language> Languages { get; } = new() { Language.CSharp };
-
-        /// <summary>
-        /// Data Points count of all timeslices of algorithm
-        /// </summary>
-        public long DataPoints => 795;
-
-        /// <summary>
-        /// Data Points count of the algorithm history
-        /// </summary>
-        public int AlgorithmHistoryDataPoints => 0;
-
-        /// <summary>
-        /// Final status of the algorithm
-        /// </summary>
-        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
-
-        /// <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 Orders", "1"},
-            {"Average Win", "0%"},
-            {"Average Loss", "0%"},
-            {"Compounding Annual Return", "0%"},
-            {"Drawdown", "0%"},
-            {"Expectancy", "0"},
-            {"Start Equity", "100000"},
-            {"End Equity", "100146.57"},
-            {"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", "$21.60"},
-            {"Estimated Strategy Capacity", "$42000000.00"},
-            {"Lowest Capacity Asset", "AAPL R735QTJ8XC9X"},
-            {"Portfolio Turnover", "99.56%"},
-            {"OrderListHash", "60f03c8c589a4f814dc4e8945df23207"}
-        };
-    }
-}

Algorithm.CSharp/AlgorithmModeAndDeploymentTargetAlgorithm.cs

@@ -1,119 +0,0 @@
-/*
- * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
- * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
-*/
-
-using System;
-using System.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 RegressionTestException($"Algorithm mode is not backtesting. Actual: {AlgorithmMode}");
-            }
-
-            if (LiveMode)
-            {
-                throw new RegressionTestException("Algorithm should not be live");
-            }
-
-            if (DeploymentTarget != DeploymentTarget.LocalPlatform)
-            {
-                throw new RegressionTestException($"Algorithm deployment target is not local. Actual{DeploymentTarget}");
-            }
-
-            // For a live deployment these checks should pass:
-            //if (AlgorithmMode != AlgorithmMode.Live) throw new RegressionTestException("Algorithm mode is not live");
-            //if (!LiveMode) throw new RegressionTestException("Algorithm should be live");
-
-            // For a cloud deployment these checks should pass:
-            //if (DeploymentTarget != DeploymentTarget.CloudPlatform) throw new RegressionTestException("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 List<Language> Languages { get; } = new() { 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>
-        /// Final status of the algorithm
-        /// </summary>
-        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
-
-        /// <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 Orders", "0"},
-            {"Average Win", "0%"},
-            {"Average Loss", "0%"},
-            {"Compounding Annual Return", "0%"},
-            {"Drawdown", "0%"},
-            {"Expectancy", "0"},
-            {"Start Equity", "100000"},
-            {"End Equity", "100000"},
-            {"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

@@ -1,287 +0,0 @@
-/*
- * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
- * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
-*/
-
-using System;
-using System.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
-{
-    /// <summary>
-    /// Tests filtering in coarse selection by shortable quantity
-    /// </summary>
-    public class AllShortableSymbolsCoarseSelectionRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
-    {
-        private static readonly DateTime _20140325 = new DateTime(2014, 3, 25);
-        private static readonly DateTime _20140326 = new DateTime(2014, 3, 26);
-        private static readonly DateTime _20140327 = new DateTime(2014, 3, 27);
-        private static readonly DateTime _20140328 = new DateTime(2014, 3, 28);
-        private static readonly DateTime _20140329 = new DateTime(2014, 3, 29);
-
-        private static readonly Symbol _aapl = QuantConnect.Symbol.Create("AAPL", SecurityType.Equity, Market.USA);
-        private static readonly Symbol _bac = QuantConnect.Symbol.Create("BAC", SecurityType.Equity, Market.USA);
-        private static readonly Symbol _gme = QuantConnect.Symbol.Create("GME", SecurityType.Equity, Market.USA);
-        private static readonly Symbol _goog = QuantConnect.Symbol.Create("GOOG", SecurityType.Equity, Market.USA);
-        private static readonly Symbol _qqq = QuantConnect.Symbol.Create("QQQ", SecurityType.Equity, Market.USA);
-        private static readonly Symbol _spy = QuantConnect.Symbol.Create("SPY", SecurityType.Equity, Market.USA);
-        private DateTime _lastTradeDate;
-
-        private static readonly Dictionary<DateTime, bool> _coarseSelected = new Dictionary<DateTime, bool>
-        {
-            { _20140325, false },
-            { _20140326, false },
-            { _20140327, false },
-            { _20140328, false },
-        };
-
-        private static readonly Dictionary<DateTime, Symbol[]> _expectedSymbols = new Dictionary<DateTime, Symbol[]>
-        {
-            { _20140325, new[]
-                {
-                    _bac,
-                    _qqq,
-                    _spy
-                }
-            },
-            { _20140326, new[]
-                {
-                    _spy
-                }
-            },
-            { _20140327, new[]
-                {
-                    _aapl,
-                    _bac,
-                    _gme,
-                    _qqq,
-                    _spy,
-                }
-            },
-            { _20140328, new[]
-                {
-                    _goog
-                }
-            },
-            { _20140329, new Symbol[0] }
-        };
-
-        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;
-
-            SetBrokerageModel(new AllShortableSymbolsRegressionAlgorithmBrokerageModel());
-        }
-
-        public override void OnData(Slice slice)
-        {
-            if (Time.Date == _lastTradeDate)
-            {
-                return;
-            }
-
-            foreach (var (symbol, security) in ActiveSecurities.Where(kvp => !kvp.Value.Invested).OrderBy(kvp => kvp.Key))
-            {
-                var shortableQuantity = security.ShortableProvider.ShortableQuantity(symbol, Time);
-                if (shortableQuantity == null)
-                {
-                    throw new RegressionTestException($"Expected {symbol} to be shortable on {Time:yyyy-MM-dd}");
-                }
-
-                // Buy at least once into all Symbols. Since daily data will always use
-                // MOO orders, it makes the testing of liquidating buying into Symbols difficult.
-                MarketOrder(symbol, -(decimal)shortableQuantity);
-                _lastTradeDate = Time.Date;
-            }
-        }
-
-        private IEnumerable<Symbol> CoarseSelection(IEnumerable<CoarseFundamental> coarse)
-        {
-            var shortableSymbols = (_security.ShortableProvider as dynamic).AllShortableSymbols(Time);
-            var selectedSymbols = coarse
-                .Select(x => x.Symbol)
-                .Where(s => shortableSymbols.ContainsKey(s) && shortableSymbols[s] >= 500)
-                .OrderBy(s => s)
-                .ToList();
-
-            var expectedMissing = 0;
-            if (Time.Date == _20140327)
-            {
-                var gme = QuantConnect.Symbol.Create("GME", SecurityType.Equity, Market.USA);
-                if (!shortableSymbols.ContainsKey(gme))
-                {
-                    throw new RegressionTestException("Expected unmapped GME in shortable symbols list on 2014-03-27");
-                }
-                if (!coarse.Select(x => x.Symbol.Value).Contains("GME"))
-                {
-                    throw new RegressionTestException("Expected mapped GME in coarse symbols on 2014-03-27");
-                }
-
-                expectedMissing = 1;
-            }
-
-            var missing = _expectedSymbols[Time.Date].Except(selectedSymbols).ToList();
-            if (missing.Count != expectedMissing)
-            {
-                throw new RegressionTestException($"Expected Symbols selected on {Time.Date:yyyy-MM-dd} to match expected Symbols, but the following Symbols were missing: {string.Join(", ", missing.Select(s => s.ToString()))}");
-            }
-
-            _coarseSelected[Time.Date] = true;
-            return selectedSymbols;
-        }
-
-        public override void OnEndOfAlgorithm()
-        {
-            if (!_coarseSelected.Values.All(x => x))
-            {
-                throw new AggregateException($"Expected coarse selection on all dates, but didn't run on: {string.Join(", ", _coarseSelected.Where(kvp => !kvp.Value).Select(kvp => kvp.Key.ToStringInvariant("yyyy-MM-dd")))}");
-            }
-        }
-
-        private class AllShortableSymbolsRegressionAlgorithmBrokerageModel : DefaultBrokerageModel
-        {
-            public AllShortableSymbolsRegressionAlgorithmBrokerageModel() : base()
-            {
-            }
-            public override IShortableProvider GetShortableProvider(Security security)
-            {
-                return new RegressionTestShortableProvider();
-            }
-        }
-
-        private class RegressionTestShortableProvider : LocalDiskShortableProvider
-        {
-            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>
-        /// 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 List<Language> Languages { get; } = new() { Language.CSharp, Language.Python };
-
-        /// <summary>
-        /// Data Points count of all timeslices of algorithm
-        /// </summary>
-        public long DataPoints => 36573;
-
-        /// <summary>
-        /// Data Points count of the algorithm history
-        /// </summary>
-        public int AlgorithmHistoryDataPoints => 0;
-
-        /// <summary>
-        /// Final status of the algorithm
-        /// </summary>
-        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
-
-        /// <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 Orders", "8"},
-            {"Average Win", "0%"},
-            {"Average Loss", "0%"},
-            {"Compounding Annual Return", "11.027%"},
-            {"Drawdown", "0.000%"},
-            {"Expectancy", "0"},
-            {"Start Equity", "10000000"},
-            {"End Equity", "10011469.88"},
-            {"Net Profit", "0.115%"},
-            {"Sharpe Ratio", "11.963"},
-            {"Sortino Ratio", "0"},
-            {"Probabilistic Sharpe Ratio", "0%"},
-            {"Loss Rate", "0%"},
-            {"Win Rate", "0%"},
-            {"Profit-Loss Ratio", "0"},
-            {"Alpha", "0.07"},
-            {"Beta", "-0.077"},
-            {"Annual Standard Deviation", "0.008"},
-            {"Annual Variance", "0"},
-            {"Information Ratio", "3.876"},
-            {"Tracking Error", "0.105"},
-            {"Treynor Ratio", "-1.215"},
-            {"Total Fees", "$282.50"},
-            {"Estimated Strategy Capacity", "$61000000000.00"},
-            {"Lowest Capacity Asset", "NB R735QTJ8XC9X"},
-            {"Portfolio Turnover", "3.62%"},
-            {"OrderListHash", "0ea806c53bfa2bdca2504ba7155ef130"}
-        };
-    }
-}

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, double> _dollarVolumeBySymbol;
+            private Dictionary<Symbol, decimal> _dollarVolumeBySymbol;
 
             public GreenBlattMagicFormulaUniverseSelectionModel() : base(true)
             {
-                _dollarVolumeBySymbol = new ();
+                _dollarVolumeBySymbol = new Dictionary<Symbol, decimal>();
             }
 
             /// <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 > 5e8
+                    where x.EarningReports.BasicAverageShares.ThreeMonths * x.EarningReports.BasicEPS.TwelveMonths * x.ValuationRatios.PERatio > 5e8m
                     select x;
 
                 double count = filteredFine.Count();
@@ -287,4 +287,4 @@ namespace QuantConnect.Algorithm.CSharp.Alphas
             }
         }
     }
-}
+}

Algorithm.CSharp/Alphas/MortgageRateVolatilityAlpha.cs

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

Algorithm.CSharp/Alphas/RebalancingLeveragedETFAlpha.cs

@@ -80,29 +80,14 @@ namespace QuantConnect.Algorithm.CSharp.Alphas
         /// <summary>
         /// This is used by the regression test system to indicate which languages this algorithm is written in.
         /// </summary>
-        public List<Language> Languages { get; } = new() { 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>
-        /// Final status of the algorithm
-        /// </summary>
-        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
+        public Language[] Languages { get; } = { Language.CSharp, Language.Python };
 
         /// <summary>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
         /// </summary>
         public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
-            {"Total Orders", "2465"},
+            {"Total Trades", "2465"},
             {"Average Win", "0.26%"},
             {"Average Loss", "-0.24%"},
             {"Compounding Annual Return", "7.848%"},
@@ -210,4 +195,4 @@ namespace QuantConnect.Algorithm.CSharp.Alphas
             UltraShort = ultraShort;
         }
     }
-}
+}

Algorithm.CSharp/Alphas/ShareClassMeanReversionAlpha.cs

@@ -31,7 +31,7 @@ namespace QuantConnect.Algorithm.CSharp.Alphas
     /// A number of companies publicly trade two different classes of shares
     /// in US equity markets. If both assets trade with reasonable volume, then
     /// the underlying driving forces of each should be similar or the same. Given
-    /// this, we can create a relatively dollar-neutral long/short portfolio using
+    /// this, we can create a relatively dollar-netural long/short portfolio using
     /// the dual share classes. Theoretically, any deviation of this portfolio from
     /// its mean-value should be corrected, and so the motivating idea is based on
     /// mean-reversion. Using a Simple Moving Average indicator, we can

Algorithm.CSharp/Alphas/VixDualThrustAlpha.cs

@@ -109,7 +109,7 @@ namespace QuantConnect.Algorithm.CSharp.Alphas
             int barsToConsolidate = 1
             )
         {
-            // coefficient that used to determine upper and lower borders of a breakout channel
+            // coefficient that used to determinte upper and lower borders of a breakout channel
             _k1 = k1;
             _k2 = k2;
 
@@ -202,7 +202,7 @@ namespace QuantConnect.Algorithm.CSharp.Alphas
                 SymbolData symbolData;
                 if (_symbolDataBySymbol.TryGetValue(removed.Symbol, out symbolData))
                 {
-                    // unsubscribe consolidator from data updates
+                    // unsibscribe consolidator from data updates
                     algorithm.SubscriptionManager.RemoveConsolidator(removed.Symbol, symbolData.GetConsolidator());
 
                     // remove item from dictionary collection

Algorithm.CSharp/AsynchronousUniverseRegressionAlgorithm.cs

@@ -1,33 +0,0 @@
-/*
- * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
- * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
-*/
-
-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

@@ -1,125 +0,0 @@
-/*
- * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
- * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
-*/
-
-using System;
-using System.Collections.Generic;
-using QuantConnect.Data;
-using QuantConnect.Indicators;
-using QuantConnect.Interfaces;
-
-namespace QuantConnect.Algorithm.CSharp
-{
-    /// <summary>
-    /// Regression algorithm to test the behaviour of ARMA versus AR models at the same order of differencing.
-    /// In particular, an ARIMA(1,1,1) and ARIMA(1,1,0) are instantiated while orders are placed if their difference
-    /// is sufficiently large (which would be due to the inclusion of the MA(1) term).
-    /// </summary>
-    public class AutoRegressiveIntegratedMovingAverageRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
-    {
-        private AutoRegressiveIntegratedMovingAverage _arima;
-        private AutoRegressiveIntegratedMovingAverage _ar;
-        private decimal _last;
-
-        public override void Initialize()
-        {
-            SetStartDate(2013, 1, 07);
-            SetEndDate(2013, 12, 11);
-
-            Settings.AutomaticIndicatorWarmUp = true;
-            AddEquity("SPY", Resolution.Daily);
-            _arima = ARIMA("SPY", 1, 1, 1, 50);
-            _ar = ARIMA("SPY", 1, 1, 0, 50);
-        }
-
-        public override void OnData(Slice slice)
-        {
-            if (_arima.IsReady)
-            {
-                if (Math.Abs(_ar.Current.Value - _arima.Current.Value) > 1) // Difference due to MA(1) being included.
-                {
-                    if (_arima.Current.Value > _last)
-                    {
-                        MarketOrder("SPY", 1);
-                    }
-                    else
-                    {
-                        MarketOrder("SPY", -1);
-                    }
-                }
-
-                _last = _arima.Current.Value;
-            }
-        }
-
-        /// <summary>
-        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
-        /// </summary>
-        public bool CanRunLocally { get; } = true;
-
-        /// <summary>
-        /// This is used by the regression test system to indicate which languages this algorithm is written in.
-        /// </summary>
-        public List<Language> Languages { get; } = new() { Language.CSharp, Language.Python };
-
-        /// <summary>
-        /// Data Points count of all timeslices of algorithm
-        /// </summary>
-        public long DataPoints => 1893;
-
-        /// <summary>
-        /// Data Points count of the algorithm history
-        /// </summary>
-        public int AlgorithmHistoryDataPoints => 100;
-
-        /// <summary>
-        /// Final status of the algorithm
-        /// </summary>
-        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
-
-        /// <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 Orders", "53"},
-            {"Average Win", "0.00%"},
-            {"Average Loss", "0.00%"},
-            {"Compounding Annual Return", "0.076%"},
-            {"Drawdown", "0.100%"},
-            {"Expectancy", "2.933"},
-            {"Start Equity", "100000"},
-            {"End Equity", "100070.90"},
-            {"Net Profit", "0.071%"},
-            {"Sharpe Ratio", "-9.164"},
-            {"Sortino Ratio", "-9.852"},
-            {"Probabilistic Sharpe Ratio", "36.417%"},
-            {"Loss Rate", "27%"},
-            {"Win Rate", "73%"},
-            {"Profit-Loss Ratio", "4.41"},
-            {"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.911"},
-            {"Total Fees", "$53.00"},
-            {"Estimated Strategy Capacity", "$16000000000.00"},
-            {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
-            {"Portfolio Turnover", "0.02%"},
-            {"OrderListHash", "685c37df6e4c49b75792c133be189094"}
-        };
-    }
-}

Algorithm.CSharp/AutomaticIndicatorWarmupDataTypeRegressionAlgorithm.cs

@@ -1,195 +0,0 @@
-/*
- * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
- * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
-*/
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using QuantConnect.Data;
-using QuantConnect.Data.Market;
-using QuantConnect.Indicators;
-using QuantConnect.Interfaces;
-using QuantConnect.Securities;
-
-namespace QuantConnect.Algorithm.CSharp
-{
-    /// <summary>
-    /// Algorithm which tests indicator warm up using different data types, related to GH issue 4205
-    /// </summary>
-    public class AutomaticIndicatorWarmupDataTypeRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
-    {
-        private Symbol _symbol;
-        public override void Initialize()
-        {
-            UniverseSettings.DataNormalizationMode = DataNormalizationMode.Raw;
-            Settings.AutomaticIndicatorWarmUp = true;
-            SetStartDate(2013, 10, 08);
-            SetEndDate(2013, 10, 10);
-
-            var SP500 = QuantConnect.Symbol.Create(Futures.Indices.SP500EMini, SecurityType.Future, Market.CME);
-            _symbol = FutureChainProvider.GetFutureContractList(SP500, StartDate).First();
-
-            // Test case: custom IndicatorBase<QuoteBar> indicator using Future unsubscribed symbol
-            var indicator1 = new CustomIndicator();
-            AssertIndicatorState(indicator1, isReady: false);
-            WarmUpIndicator(_symbol, indicator1);
-            AssertIndicatorState(indicator1, isReady: true);
-
-            // Test case: SimpleMovingAverage<IndicatorDataPoint> using Future unsubscribed symbol (should use TradeBar)
-            var sma1 = new SimpleMovingAverage(10);
-            AssertIndicatorState(sma1, isReady: false);
-            WarmUpIndicator(_symbol, sma1);
-            AssertIndicatorState(sma1, isReady: true);
-
-            // Test case: SimpleMovingAverage<IndicatorDataPoint> using Equity unsubscribed symbol
-            var spy = QuantConnect.Symbol.Create("SPY", SecurityType.Equity, Market.USA);
-            var sma = new SimpleMovingAverage(10);
-            AssertIndicatorState(sma, isReady: false);
-            WarmUpIndicator(spy, sma);
-            AssertIndicatorState(sma, isReady: true);
-
-            // We add the symbol
-            AddFutureContract(_symbol);
-            AddEquity("SPY");
-            // force spy for use Raw data mode so that it matches the used when unsubscribed which uses the universe settings
-            SubscriptionManager.SubscriptionDataConfigService.GetSubscriptionDataConfigs(spy).SetDataNormalizationMode(DataNormalizationMode.Raw);
-
-            // Test case: custom IndicatorBase<QuoteBar> indicator using Future subscribed symbol
-            var indicator = new CustomIndicator();
-            var consolidator = CreateConsolidator(TimeSpan.FromMinutes(2), typeof(QuoteBar));
-            RegisterIndicator(_symbol, indicator, consolidator);
-
-            AssertIndicatorState(indicator, isReady: false);
-            WarmUpIndicator(_symbol, indicator);
-            AssertIndicatorState(indicator, isReady: true);
-
-            // Test case: SimpleMovingAverage<IndicatorDataPoint> using Future Subscribed symbol (should use TradeBar)
-            var sma11 = new SimpleMovingAverage(10);
-            AssertIndicatorState(sma11, isReady: false);
-            WarmUpIndicator(_symbol, sma11);
-            AssertIndicatorState(sma11, isReady: true);
-
-            if (!sma11.Current.Equals(sma1.Current))
-            {
-                throw new RegressionTestException("Expected SMAs warmed up before and after adding the Future to the algorithm to have the same current value. " +
-                                    "The result of 'WarmUpIndicator' shouldn't change if the symbol is or isn't subscribed");
-            }
-
-            // Test case: SimpleMovingAverage<IndicatorDataPoint> using Equity unsubscribed symbol
-            var smaSpy = new SimpleMovingAverage(10);
-            AssertIndicatorState(smaSpy, isReady: false);
-            WarmUpIndicator(spy, smaSpy);
-            AssertIndicatorState(smaSpy, isReady: true);
-
-            if (!smaSpy.Current.Equals(sma.Current))
-            {
-                throw new RegressionTestException("Expected SMAs warmed up before and after adding the Equity to the algorithm to have the same current value. " +
-                                    "The result of 'WarmUpIndicator' shouldn't change if the symbol is or isn't subscribed");
-            }
-        }
-
-        private void AssertIndicatorState(IIndicator indicator, bool isReady)
-        {
-            if (indicator.IsReady != isReady)
-            {
-                throw new RegressionTestException($"Expected indicator state, expected {isReady} but was {indicator.IsReady}");
-            }
-        }
-
-        /// <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 slice)
-        {
-            if (!Portfolio.Invested)
-            {
-                SetHoldings(_symbol, 0.5);
-            }
-        }
-
-        private class CustomIndicator : IndicatorBase<QuoteBar>, IIndicatorWarmUpPeriodProvider
-        {
-            private bool _isReady;
-            public int WarmUpPeriod => 1;
-            public override bool IsReady => _isReady;
-            public CustomIndicator() : base("Pepe")
-            { }
-            protected override decimal ComputeNextValue(QuoteBar input)
-            {
-                _isReady = true;
-                return input.Ask.High;
-            }
-        }
-
-        /// <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 List<Language> Languages { get; } = new() { Language.CSharp };
-
-        /// <summary>
-        /// Data Points count of all timeslices of algorithm
-        /// </summary>
-        public long DataPoints => 6426;
-
-        /// <summary>
-        /// Data Points count of the algorithm history
-        /// </summary>
-        public int AlgorithmHistoryDataPoints => 84;
-
-        /// <summary>
-        /// Final status of the algorithm
-        /// </summary>
-        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
-
-        /// <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 Orders", "1"},
-            {"Average Win", "0%"},
-            {"Average Loss", "0%"},
-            {"Compounding Annual Return", "733913.744%"},
-            {"Drawdown", "15.900%"},
-            {"Expectancy", "0"},
-            {"Start Equity", "100000"},
-            {"End Equity", "106827.7"},
-            {"Net Profit", "6.828%"},
-            {"Sharpe Ratio", "203744786353.299"},
-            {"Sortino Ratio", "0"},
-            {"Probabilistic Sharpe Ratio", "0%"},
-            {"Loss Rate", "0%"},
-            {"Win Rate", "0%"},
-            {"Profit-Loss Ratio", "0"},
-            {"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.717"},
-            {"Total Fees", "$23.65"},
-            {"Estimated Strategy Capacity", "$200000000.00"},
-            {"Lowest Capacity Asset", "ES VMKLFZIH2MTD"},
-            {"Portfolio Turnover", "351.80%"},
-            {"OrderListHash", "dfd9a280d3c6470b305c03e0b72c234e"}
-        };
-    }
-}

Algorithm.CSharp/AutomaticIndicatorWarmupOptionIndicatorsMirrorContractsRegressionAlgorithm.cs

@@ -1,126 +0,0 @@
-/*
- * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
- * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
-*/
-
-using System;
-using QuantConnect.Indicators;
-using QuantConnect.Interfaces;
-using System.Collections.Generic;
-
-namespace QuantConnect.Algorithm.CSharp
-{
-    /// <summary>
-    /// Regression algorithm asserting the behavior of the AutomaticIndicatorWarmUp on option greeks
-    /// </summary>
-    public class AutomaticIndicatorWarmupOptionIndicatorsMirrorContractsRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
-    {
-        public override void Initialize()
-        {
-            SetStartDate(2015, 12, 24);
-            SetEndDate(2015, 12, 24);
-
-            Settings.AutomaticIndicatorWarmUp = true;
-
-            var underlying = "GOOG";
-            var resolution = Resolution.Minute;
-
-            var expiration = new DateTime(2015, 12, 24);
-            var strike = 650m;
-
-            var equity = AddEquity(underlying, resolution).Symbol;
-            var option = QuantConnect.Symbol.CreateOption(underlying, Market.USA, OptionStyle.American, OptionRight.Put, strike, expiration);
-            AddOptionContract(option, resolution);
-            // add the call counter side of the mirrored pair
-            var mirrorOption = QuantConnect.Symbol.CreateOption(underlying, Market.USA, OptionStyle.American, OptionRight.Call, strike, expiration);
-            AddOptionContract(mirrorOption, resolution);
-
-            var impliedVolatility = IV(option, mirrorOption);
-            var delta = D(option, mirrorOption, optionModel: OptionPricingModelType.BinomialCoxRossRubinstein, ivModel: OptionPricingModelType.BlackScholes);
-            var gamma = G(option, mirrorOption, optionModel: OptionPricingModelType.ForwardTree, ivModel: OptionPricingModelType.BlackScholes);
-            var vega = V(option, mirrorOption, optionModel: OptionPricingModelType.ForwardTree, ivModel: OptionPricingModelType.BlackScholes);
-            var theta = T(option, mirrorOption, optionModel: OptionPricingModelType.ForwardTree, ivModel: OptionPricingModelType.BlackScholes);
-            var rho = R(option, mirrorOption, optionModel: OptionPricingModelType.ForwardTree, ivModel: OptionPricingModelType.BlackScholes);
-
-            if (impliedVolatility == 0m || delta == 0m || gamma == 0m || vega == 0m || theta == 0m || rho == 0m)
-            {
-                throw new RegressionTestException("Expected IV/greeks calculated");
-            }
-            if (!impliedVolatility.IsReady || !delta.IsReady || !gamma.IsReady || !vega.IsReady || !theta.IsReady || !rho.IsReady)
-            {
-                throw new RegressionTestException("Expected IV/greeks to be ready");
-            }
-
-            Quit($"Implied Volatility: {impliedVolatility}, Delta: {delta}, Gamma: {gamma}, Vega: {vega}, Theta: {theta}, Rho: {rho}");
-        }
-
-        /// <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 => true;
-
-        /// <summary>
-        /// This is used by the regression test system to indicate which languages this algorithm is written in.
-        /// </summary>
-        public List<Language> Languages { get; } = new() { Language.CSharp };
-
-        /// <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 => 21;
-
-        /// <summary>
-        /// Final status of the algorithm
-        /// </summary>
-        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
-
-        /// <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 Orders", "0"},
-            {"Average Win", "0%"},
-            {"Average Loss", "0%"},
-            {"Compounding Annual Return", "0%"},
-            {"Drawdown", "0%"},
-            {"Expectancy", "0"},
-            {"Start Equity", "100000"},
-            {"End Equity", "100000"},
-            {"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/AutomaticIndicatorWarmupRegressionAlgorithm.cs

@@ -1,157 +0,0 @@
-/*
- * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
- * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
-*/
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using QuantConnect.Data;
-using QuantConnect.Indicators;
-using QuantConnect.Interfaces;
-
-namespace QuantConnect.Algorithm.CSharp
-{
-    /// <summary>
-    /// Algorithm which reproduces GH issue 3861, where in some cases 2 consolidators were added when
-    /// using the automatic indicator warmup feature
-    /// </summary>
-    public class AutomaticIndicatorWarmupRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
-    {
-        private Symbol _spy;
-        public override void Initialize()
-        {
-            SetStartDate(2013, 10, 07);
-            SetEndDate(2013, 10, 11);
-
-            Settings.AutomaticIndicatorWarmUp = true;
-
-            // Test case 1
-            _spy = AddEquity("SPY").Symbol;
-            var sma = SMA(_spy, 10);
-            if (!sma.IsReady)
-            {
-                throw new RegressionTestException("Expected SMA to be warmed up");
-            }
-
-            // Test case 2
-            var indicator = new CustomIndicator(10);
-            RegisterIndicator(_spy, indicator, Resolution.Minute, (Func<IBaseData, decimal>) null);
-
-            if (indicator.IsReady)
-            {
-                throw new RegressionTestException("Expected CustomIndicator Not to be warmed up");
-            }
-            WarmUpIndicator(_spy, indicator);
-            if (!indicator.IsReady)
-            {
-                throw new RegressionTestException("Expected CustomIndicator to be warmed up");
-            }
-        }
-
-        /// <summary>
-        /// OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here.
-        /// </summary>
-        /// <param name="slice">Slice object keyed by symbol containing the stock data</param>
-        public override void OnData(Slice slice)
-        {
-            if (!Portfolio.Invested)
-            {
-                var subscription = SubscriptionManager.SubscriptionDataConfigService.GetSubscriptionDataConfigs(_spy).First(config => config.TickType == TickType.Trade);
-
-                // we expect 1 consolidator per indicator
-                if (subscription.Consolidators.Count != 2)
-                {
-                    throw new RegressionTestException($"Unexpected consolidator count for subscription: {subscription.Consolidators.Count}");
-                }
-                SetHoldings(_spy, 1);
-            }
-        }
-
-        private class CustomIndicator : SimpleMovingAverage
-        {
-            private IndicatorDataPoint _previous;
-            public CustomIndicator(int period) : base(period)
-            {
-            }
-            protected override decimal ComputeNextValue(IReadOnlyWindow<IndicatorDataPoint> window, IndicatorDataPoint input)
-            {
-                if (_previous != null && input.EndTime == _previous.EndTime)
-                {
-                    throw new RegressionTestException($"Unexpected indicator double data point call: {_previous}");
-                }
-                _previous = input;
-                return base.ComputeNextValue(window, input);
-            }
-        }
-
-        /// <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 List<Language> Languages { get; } = new() { Language.CSharp };
-
-        /// <summary>
-        /// Data Points count of all timeslices of algorithm
-        /// </summary>
-        public long DataPoints => 3943;
-
-        /// <summary>
-        /// Data Points count of the algorithm history
-        /// </summary>
-        public int AlgorithmHistoryDataPoints => 40;
-
-        /// <summary>
-        /// Final status of the algorithm
-        /// </summary>
-        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
-
-        /// <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 Orders", "1"},
-            {"Average Win", "0%"},
-            {"Average Loss", "0%"},
-            {"Compounding Annual Return", "271.453%"},
-            {"Drawdown", "2.200%"},
-            {"Expectancy", "0"},
-            {"Start Equity", "100000"},
-            {"End Equity", "101691.92"},
-            {"Net Profit", "1.692%"},
-            {"Sharpe Ratio", "8.854"},
-            {"Sortino Ratio", "0"},
-            {"Probabilistic Sharpe Ratio", "67.609%"},
-            {"Loss Rate", "0%"},
-            {"Win Rate", "0%"},
-            {"Profit-Loss Ratio", "0"},
-            {"Alpha", "-0.005"},
-            {"Beta", "0.996"},
-            {"Annual Standard Deviation", "0.222"},
-            {"Annual Variance", "0.049"},
-            {"Information Ratio", "-14.565"},
-            {"Tracking Error", "0.001"},
-            {"Treynor Ratio", "1.97"},
-            {"Total Fees", "$3.44"},
-            {"Estimated Strategy Capacity", "$56000000.00"},
-            {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
-            {"Portfolio Turnover", "19.93%"},
-            {"OrderListHash", "3da9fa60bf95b9ed148b95e02e0cfc9e"}
-        };
-    }
-}

Algorithm.CSharp/AuxiliaryDataHandlersRegressionAlgorithm.cs

@@ -1,168 +0,0 @@
-/*
- * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
- * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
-*/
-
-using System;
-using QuantConnect.Interfaces;
-using QuantConnect.Data.Market;
-using System.Collections.Generic;
-
-namespace QuantConnect.Algorithm.CSharp
-{
-    /// <summary>
-    /// Example algorithm using and asserting the behavior of auxiliary Data handlers
-    /// </summary>
-    public class AuxiliaryDataHandlersRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
-    {
-        private bool _onSplits;
-        private bool _onDividends;
-        private bool _onDelistingsCalled;
-        private bool _onSymbolChangedEvents;
-
-        /// <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(2007, 05, 16);
-            SetEndDate(2015, 1, 1);
-
-            UniverseSettings.Resolution = Resolution.Daily;
-
-            // will get delisted
-            AddEquity("AAA.1");
-
-            // get's remapped
-            AddEquity("SPWR");
-
-            // has a split & dividends
-            AddEquity("AAPL");
-        }
-
-        public override void OnDelistings(Delistings delistings)
-        {
-            if (!delistings.ContainsKey("AAA.1"))
-            {
-                throw new RegressionTestException("Unexpected OnDelistings call");
-            }
-            _onDelistingsCalled = true;
-        }
-
-        public override void OnSymbolChangedEvents(SymbolChangedEvents symbolsChanged)
-        {
-            if (!symbolsChanged.ContainsKey("SPWR"))
-            {
-                throw new RegressionTestException("Unexpected OnSymbolChangedEvents call");
-            }
-            _onSymbolChangedEvents = true;
-        }
-
-        public override void OnSplits(Splits splits)
-        {
-            if (!splits.ContainsKey("AAPL"))
-            {
-                throw new RegressionTestException("Unexpected OnSplits call");
-            }
-            _onSplits = true;
-        }
-
-        public override void OnDividends(Dividends dividends)
-        {
-            if (!dividends.ContainsKey("AAPL"))
-            {
-                throw new RegressionTestException("Unexpected OnDividends call");
-            }
-            _onDividends = true;
-        }
-
-        public override void OnEndOfAlgorithm()
-        {
-            if (!_onDelistingsCalled)
-            {
-                throw new RegressionTestException("OnDelistings was not called!");
-            }
-            if (!_onSymbolChangedEvents)
-            {
-                throw new RegressionTestException("OnSymbolChangedEvents was not called!");
-            }
-            if (!_onSplits)
-            {
-                throw new RegressionTestException("OnSplits was not called!");
-            }
-            if (!_onDividends)
-            {
-                throw new RegressionTestException("OnDividends was not called!");
-            }
-        }
-
-        /// <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 List<Language> Languages { get; } = new() { Language.CSharp, Language.Python };
-
-        /// <summary>
-        /// Data Points count of all timeslices of algorithm
-        /// </summary>
-        public long DataPoints => 126221;
-
-        /// <summary>
-        /// Data Points count of the algorithm history
-        /// </summary>
-        public int AlgorithmHistoryDataPoints => 0;
-
-        /// <summary>
-        /// Final status of the algorithm
-        /// </summary>
-        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
-
-        /// <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 Orders", "0"},
-            {"Average Win", "0%"},
-            {"Average Loss", "0%"},
-            {"Compounding Annual Return", "0%"},
-            {"Drawdown", "0%"},
-            {"Expectancy", "0"},
-            {"Start Equity", "100000"},
-            {"End Equity", "100000"},
-            {"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.332"},
-            {"Tracking Error", "0.183"},
-            {"Treynor Ratio", "0"},
-            {"Total Fees", "$0.00"},
-            {"Estimated Strategy Capacity", "$0"},
-            {"Lowest Capacity Asset", ""},
-            {"Portfolio Turnover", "0%"},
-            {"OrderListHash", "d41d8cd98f00b204e9800998ecf8427e"}
-        };
-    }
-}

Algorithm.CSharp/BacktestingBrokerageRegressionAlgorithm.cs

@@ -1,345 +0,0 @@
-/*
- * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
- * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
-*/
-
-using QuantConnect.Data;
-using QuantConnect.Data.Market;
-using QuantConnect.Interfaces;
-using QuantConnect.Orders;
-using QuantConnect.Orders.Fees;
-using QuantConnect.Orders.Fills;
-using QuantConnect.Securities;
-using QuantConnect.Securities.Option;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-
-namespace QuantConnect.Algorithm.CSharp
-{
-    /// <summary>
-    /// This regression algorithm tests the order processing of the backtesting brokerage.
-    /// We open an equity position that should fill in two parts, on two different bars.
-    /// We open a long option position and let it expire so we can exercise the position.
-    /// To check the orders we use OnOrderEvent and throw exceptions if verification fails.
-    /// </summary>
-    /// <meta name="tag" content="backtesting brokerage" />
-    /// <meta name="tag" content="regression test" />
-    /// <meta name="tag" content="options" />
-    class BacktestingBrokerageRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
-    {
-        private Security _security;
-        private Symbol _spy;
-        private OrderTicket _equityBuy;
-        private Option _option;
-        private Symbol _optionSymbol;
-        private OrderTicket _optionBuy;
-        private bool _optionBought = false;
-        private bool _equityBought = false;
-        private decimal _optionStrikePrice;
-
-        /// <summary>
-        /// Initialize the algorithm
-        /// </summary>
-        public override void Initialize()
-        {
-            SetCash(100000);
-            SetStartDate(2015, 12, 24);
-            SetEndDate(2015, 12, 28);
-
-            // Get our equity
-            _security = AddEquity("SPY", Resolution.Hour);
-            _security.SetFillModel(new PartialMarketFillModel(2));
-            _spy = _security.Symbol;
-
-            // Get our option
-            _option = AddOption("GOOG");
-            _option.SetFilter(u => u.IncludeWeeklys()
-                                   .Strikes(-2, +2)
-                                   .Expiration(TimeSpan.Zero, TimeSpan.FromDays(10)));
-            _optionSymbol = _option.Symbol;
-        }
-
-        /// <summary>
-        /// OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here.
-        /// </summary>
-        /// <param name="data">Slice object keyed by symbol containing the stock data</param>
-        public override void OnData(Slice data)
-        {
-            if (!_equityBought && data.ContainsKey(_spy))
-            {
-                //Buy our Equity.
-                //Quantity is rounded down to an even number since it will be split in two equal halves
-                var quantity = Math.Floor(CalculateOrderQuantity(_spy, .1m) / 2) * 2;
-                _equityBuy = MarketOrder(_spy, quantity, asynchronous: true);
-                _equityBought = true;
-            }
-
-            if (!_optionBought)
-            {
-                // Buy our option
-                OptionChain chain;
-                if (data.OptionChains.TryGetValue(_optionSymbol, out chain))
-                {
-                    // Find the second call strike under market price expiring today
-                    var contracts = (
-                        from optionContract in chain.OrderByDescending(x => x.Strike)
-                        where optionContract.Right == OptionRight.Call
-                        where optionContract.Expiry == Time.Date
-                        where optionContract.Strike < chain.Underlying.Price
-                        select optionContract
-                        ).Take(2);
-
-                    if (contracts.Any())
-                    {
-                        var optionToBuy = contracts.FirstOrDefault();
-                        _optionStrikePrice = optionToBuy.Strike;
-                        _optionBuy = MarketOrder(optionToBuy.Symbol, 1);
-                        _optionBought = true;
-                    }
-                }
-            }
-        }
-
-        /// <summary>
-        /// All order events get pushed through this function
-        /// </summary>
-        /// <param name="orderEvent">OrderEvent object that contains all the information about the event</param>
-        public override void OnOrderEvent(OrderEvent orderEvent)
-        {
-            // Get the order from our transactions
-            var order = Transactions.GetOrderById(orderEvent.OrderId);
-
-            // Based on the type verify the order
-            switch (order.Type)
-            {
-                case OrderType.Market:
-                    VerifyMarketOrder(order, orderEvent);
-                    break;
-
-                case OrderType.OptionExercise:
-                    VerifyOptionExercise(order, orderEvent);
-                    break;
-
-                default:
-                    throw new ArgumentOutOfRangeException();
-            }
-        }
-
-        /// <summary>
-        /// To verify Market orders is process correctly
-        /// </summary>
-        /// <param name="order">Order object to analyze</param>
-        public void VerifyMarketOrder(Order order, OrderEvent orderEvent)
-        {
-            switch (order.Status)
-            {
-                case OrderStatus.Submitted:
-                    break;
-
-                // All PartiallyFilled orders should have a LastFillTime
-                case OrderStatus.PartiallyFilled:
-                    if (order.LastFillTime == null)
-                    {
-                        throw new RegressionTestException("LastFillTime should not be null");
-                    }
-
-                    if (order.Quantity / 2 != orderEvent.FillQuantity)
-                    {
-                        throw new RegressionTestException("Order size should be half");
-                    }
-                    break;
-
-                // All filled equity orders should have filled after creation because of our fill model!
-                case OrderStatus.Filled:
-                    if (order.SecurityType == SecurityType.Equity && order.CreatedTime == order.LastFillTime)
-                    {
-                        throw new RegressionTestException("Order should not finish during the CreatedTime bar");
-                    }
-                    break;
-
-                default:
-                    throw new ArgumentOutOfRangeException();
-            }
-        }
-
-        /// <summary>
-        /// To verify OptionExercise orders is process correctly
-        /// </summary>
-        /// <param name="order">Order object to analyze</param>
-        public void VerifyOptionExercise(Order order, OrderEvent orderEvent)
-        {
-            // If the option price isn't the same as the strike price, its incorrect
-            if (order.Price != _optionStrikePrice)
-            {
-                throw new RegressionTestException("OptionExercise order price should be strike price!!");
-            }
-
-            if (orderEvent.Quantity != -1)
-            {
-                throw new RegressionTestException("OrderEvent Quantity should be -1");
-            }
-        }
-
-        /// <summary>
-        /// Runs after algorithm, used to check our portfolio and orders
-        /// </summary>
-        public override void OnEndOfAlgorithm()
-        {
-            if (!Portfolio.ContainsKey(_optionBuy.Symbol) || !Portfolio.ContainsKey(_optionBuy.Symbol.Underlying) || !Portfolio.ContainsKey(_equityBuy.Symbol))
-            {
-                throw new RegressionTestException("Portfolio does not contain the Symbols we purchased");
-            }
-
-            //Check option holding, should not be invested since it expired, profit should be -400
-            var optionHolding = Portfolio[_optionBuy.Symbol];
-            if (optionHolding.Invested || optionHolding.Profit != -400)
-            {
-                throw new RegressionTestException("Options holding does not match expected outcome");
-            }
-
-            //Check the option underlying symbol since we should have bought it at exercise
-            //Quantity should be 100, AveragePrice should be option strike price
-            var optionExerciseHolding = Portfolio[_optionBuy.Symbol.Underlying];
-            if (!optionExerciseHolding.Invested || optionExerciseHolding.Quantity != 100 || optionExerciseHolding.AveragePrice != _optionBuy.Symbol.ID.StrikePrice)
-            {
-                throw new RegressionTestException("Equity holding for exercised option does not match expected outcome");
-            }
-
-            //Check equity holding, should be invested, profit should be
-            //Quantity should be 52, AveragePrice should be ticket AverageFillPrice
-            var equityHolding = Portfolio[_equityBuy.Symbol];
-            if (!equityHolding.Invested || equityHolding.Quantity != 52 || equityHolding.AveragePrice != _equityBuy.AverageFillPrice)
-            {
-                throw new RegressionTestException("Equity holding does not match expected outcome");
-            }
-        }
-
-        /// <summary>
-        /// PartialMarketFillModel that allows the user to set the number of fills and restricts
-        /// the fill to only one per bar.
-        /// </summary>
-        private class PartialMarketFillModel : ImmediateFillModel
-        {
-            private readonly decimal _percent;
-            private readonly Dictionary<long, decimal> _absoluteRemainingByOrderId = new Dictionary<long, decimal>();
-
-            /// <param name="numberOfFills"></param>
-            public PartialMarketFillModel(int numberOfFills = 1)
-            {
-                _percent = 1m / numberOfFills;
-            }
-
-            /// <summary>
-            /// Performs partial market fills once per time step
-            /// </summary>
-            /// <param name="asset">The security being ordered</param>
-            /// <param name="order">The order</param>
-            /// <returns>The order fill</returns>
-            public override OrderEvent MarketFill(Security asset, MarketOrder order)
-            {
-                var currentUtcTime = asset.LocalTime.ConvertToUtc(asset.Exchange.TimeZone);
-
-                // Only fill once a time slice
-                if (order.LastFillTime != null && currentUtcTime <= order.LastFillTime)
-                {
-                    return new OrderEvent(order, currentUtcTime, OrderFee.Zero);
-                }
-
-                decimal absoluteRemaining;
-                if (!_absoluteRemainingByOrderId.TryGetValue(order.Id, out absoluteRemaining))
-                {
-                    absoluteRemaining = order.AbsoluteQuantity;
-                    _absoluteRemainingByOrderId.Add(order.Id, order.AbsoluteQuantity);
-                }
-
-                var fill = base.MarketFill(asset, order);
-                var absoluteFillQuantity = (int)(Math.Min(absoluteRemaining, (int)(_percent * order.Quantity)));
-                fill.FillQuantity = Math.Sign(order.Quantity) * absoluteFillQuantity;
-
-                if (absoluteRemaining == absoluteFillQuantity)
-                {
-                    fill.Status = OrderStatus.Filled;
-                    _absoluteRemainingByOrderId.Remove(order.Id);
-                }
-                else
-                {
-                    absoluteRemaining = absoluteRemaining - absoluteFillQuantity;
-                    _absoluteRemainingByOrderId[order.Id] = absoluteRemaining;
-                    fill.Status = OrderStatus.PartiallyFilled;
-                }
-
-                return fill;
-            }
-        }
-
-        /// <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 List<Language> Languages { get; } = new() { Language.CSharp };
-
-        /// <summary>
-        /// Data Points count of all timeslices of algorithm
-        /// </summary>
-        public long DataPoints => 27071;
-
-        /// <summary>
-        /// Data Points count of the algorithm history
-        /// </summary>
-        public int AlgorithmHistoryDataPoints => 0;
-
-        /// <summary>
-        /// Final status of the algorithm
-        /// </summary>
-        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
-
-        /// <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 Orders", "3"},
-            {"Average Win", "0%"},
-            {"Average Loss", "-0.40%"},
-            {"Compounding Annual Return", "-21.378%"},
-            {"Drawdown", "0.400%"},
-            {"Expectancy", "-1"},
-            {"Start Equity", "100000"},
-            {"End Equity", "99671.06"},
-            {"Net Profit", "-0.329%"},
-            {"Sharpe Ratio", "-14.095"},
-            {"Sortino Ratio", "0"},
-            {"Probabilistic Sharpe Ratio", "1.216%"},
-            {"Loss Rate", "100%"},
-            {"Win Rate", "0%"},
-            {"Profit-Loss Ratio", "0"},
-            {"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.234"},
-            {"Total Fees", "$2.00"},
-            {"Estimated Strategy Capacity", "$0"},
-            {"Lowest Capacity Asset", "GOOCV VP83T1ZUHROL"},
-            {"Portfolio Turnover", "17.02%"},
-            {"OrderListHash", "b1e5e72fb766ab894204bc4b1300912b"}
-        };
-    }
-}

Algorithm.CSharp/BaseFrameworkRegressionAlgorithm.cs

@@ -1,100 +0,0 @@
-/*
- * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
- * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
-*/
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using QuantConnect.Algorithm.Framework.Alphas;
-using QuantConnect.Algorithm.Framework.Execution;
-using QuantConnect.Algorithm.Framework.Portfolio;
-using QuantConnect.Algorithm.Framework.Risk;
-using QuantConnect.Algorithm.Framework.Selection;
-using QuantConnect.Interfaces;
-
-namespace QuantConnect.Algorithm.CSharp
-{
-    /// <summary>
-    /// Abstract regression framework algorithm for multiple framework regression tests
-    /// </summary>
-    public abstract class BaseFrameworkRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
-    {
-        public override void Initialize()
-        {
-            SetStartDate(2014, 6, 1);
-            SetEndDate(2014, 6, 30);
-
-            UniverseSettings.Resolution = Resolution.Hour;
-            UniverseSettings.DataNormalizationMode = DataNormalizationMode.Raw;
-
-            var symbols = new[] { "AAPL", "AIG", "BAC", "SPY" }
-                .Select(ticker => QuantConnect.Symbol.Create(ticker, SecurityType.Equity, Market.USA))
-                .ToList();
-
-            // Manually add AAPL and AIG when the algorithm starts
-            SetUniverseSelection(new ManualUniverseSelectionModel(symbols.Take(2)));
-
-            // At midnight, add all securities every day except on the last data
-            // With this procedure, the Alpha Model will experience multiple universe changes
-            AddUniverseSelection(new ScheduledUniverseSelectionModel(
-                DateRules.EveryDay(), TimeRules.Midnight,
-                dt => dt < EndDate.AddDays(-1) ? symbols : Enumerable.Empty<Symbol>()));
-
-            SetAlpha(new ConstantAlphaModel(InsightType.Price, InsightDirection.Up, TimeSpan.FromDays(31), 0.025, null));
-            SetPortfolioConstruction(new EqualWeightingPortfolioConstructionModel());
-            SetExecution(new ImmediateExecutionModel());
-            SetRiskManagement(new NullRiskManagementModel());
-        }
-
-        public override void OnEndOfAlgorithm()
-        {
-            // The base implementation checks for active insights
-            var insightsCount = Insights.GetInsights(insight => insight.IsActive(UtcTime)).Count;
-            if (insightsCount != 0)
-            {
-                throw new RegressionTestException($"The number of active insights should be 0. Actual: {insightsCount}");
-            }
-        }
-
-        /// <summary>
-        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
-        /// </summary>
-        public bool CanRunLocally { get; } = true;
-
-        /// <summary>
-        /// This is used by the regression test system to indicate which languages this algorithm is written in.
-        /// </summary>
-        public virtual List<Language> Languages { get; } = new() { Language.CSharp, Language.Python };
-
-        /// <summary>
-        /// Data Points count of all timeslices of algorithm
-        /// </summary>
-        public virtual long DataPoints => 765;
-
-        /// <summary>
-        /// Data Points count of the algorithm history
-        /// </summary>
-        public virtual int AlgorithmHistoryDataPoints => 0;
-
-        /// <summary>
-        /// Final status of the algorithm
-        /// </summary>
-        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
-
-        /// <summary>
-        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
-        /// </summary>
-        public abstract Dictionary<string, string> ExpectedStatistics { get; }
-    }
-}

Algorithm.CSharp/BasicPythonIntegrationTemplateAlgorithm.cs

@@ -49,7 +49,7 @@ namespace QuantConnect.Algorithm.CSharp
 
         /// OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here.
         /// Slice object keyed by symbol containing the stock data
-        public override void OnData(Slice slice)
+        public override void OnData(Slice data)
         {
             if (!Portfolio.Invested)
             {
@@ -63,4 +63,4 @@ namespace QuantConnect.Algorithm.CSharp
             }
         }
     }
-}
+}

Algorithm.CSharp/BasicSetAccountCurrencyAlgorithm.cs

@@ -1,4 +1,4 @@
-/*
+/*
  * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
  * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
  *
@@ -14,7 +14,6 @@
 */
 
 using System.Collections.Generic;
-using QuantConnect.Brokerages;
 using QuantConnect.Data;
 using QuantConnect.Interfaces;
 
@@ -34,23 +33,18 @@ 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>
         /// 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 slice)
+        public override void OnData(Slice data)
         {
             if (!Portfolio.Invested)
             {
@@ -67,55 +61,32 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// This is used by the regression test system to indicate which languages this algorithm is written in.
         /// </summary>
-        public List<Language> Languages { get; } = new() { 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>
-        /// Final status of the algorithm
-        /// </summary>
-        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
+        public Language[] Languages { get; } = { Language.CSharp, Language.Python };
 
         /// <summary>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
         /// </summary>
         public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
-            {"Total Orders", "1"},
+            {"Total Trades", "1"},
             {"Average Win", "0%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "0%"},
-            {"Drawdown", "0%"},
+            {"Compounding Annual Return", "-100.000%"},
+            {"Drawdown", "11.000%"},
             {"Expectancy", "0"},
-            {"Start Equity", "100000.00"},
-            {"End Equity", "92395.59"},
-            {"Net Profit", "0%"},
-            {"Sharpe Ratio", "0"},
-            {"Sortino Ratio", "0"},
-            {"Probabilistic Sharpe Ratio", "0%"},
+            {"Net Profit", "-7.328%"},
+            {"Sharpe Ratio", "-12.15"},
             {"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", "€298.35"},
-            {"Estimated Strategy Capacity", "€85000.00"},
-            {"Lowest Capacity Asset", "BTCEUR 2XR"},
-            {"Portfolio Turnover", "107.64%"},
-            {"OrderListHash", "6819dc936b86af6e4b89b6017b7d5284"}
+            {"Alpha", "-17.811"},
+            {"Beta", "1239.638"},
+            {"Annual Standard Deviation", "0.762"},
+            {"Annual Variance", "0.581"},
+            {"Information Ratio", "-12.169"},
+            {"Tracking Error", "0.761"},
+            {"Treynor Ratio", "-0.007"},
+            {"Total Fees", "$0.00"}
         };
     }
 }

Algorithm.CSharp/BasicSetAccountCurrencyWithAmountAlgorithm.cs

@@ -1,91 +0,0 @@
-/*
- * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
- * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
-*/
-
-using System.Collections.Generic;
-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 List<Language> Languages { get; } = new() { 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>
-        /// Final status of the algorithm
-        /// </summary>
-        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
-
-        /// <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 Orders", "1"},
-            {"Average Win", "0%"},
-            {"Average Loss", "0%"},
-            {"Compounding Annual Return", "0%"},
-            {"Drawdown", "0%"},
-            {"Expectancy", "0"},
-            {"Start Equity", "200000.00"},
-            {"End Equity", "184791.19"},
-            {"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", "3d450fd418a0e845b3eaaac17fcd13fc"}
-        };
-    }
-}

Algorithm.CSharp/BasicTemplateAlgorithm.cs

@@ -53,7 +53,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// 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 slice)
+        public override void OnData(Slice data)
         {
             if (!Portfolio.Invested)
             {
@@ -70,55 +70,32 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// This is used by the regression test system to indicate which languages this algorithm is written in.
         /// </summary>
-        public List<Language> Languages { get; } = new() { Language.CSharp, Language.Python };
-
-        /// <summary>
-        /// Data Points count of all timeslices of algorithm
-        /// </summary>
-        public long DataPoints => 3943;
-
-        /// <summary>
-        /// Data Points count of the algorithm history
-        /// </summary>
-        public int AlgorithmHistoryDataPoints => 0;
-
-        /// <summary>
-        /// Final status of the algorithm
-        /// </summary>
-        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
+        public Language[] Languages { get; } = { Language.CSharp, Language.Python };
 
         /// <summary>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
         /// </summary>
         public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
-            {"Total Orders", "1"},
+            {"Total Trades", "1"},
             {"Average Win", "0%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "271.453%"},
+            {"Compounding Annual Return", "263.153%"},
             {"Drawdown", "2.200%"},
             {"Expectancy", "0"},
-            {"Start Equity", "100000"},
-            {"End Equity", "101691.92"},
-            {"Net Profit", "1.692%"},
-            {"Sharpe Ratio", "8.854"},
-            {"Sortino Ratio", "0"},
-            {"Probabilistic Sharpe Ratio", "67.609%"},
+            {"Net Profit", "1.663%"},
+            {"Sharpe Ratio", "4.41"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "-0.005"},
-            {"Beta", "0.996"},
-            {"Annual Standard Deviation", "0.222"},
-            {"Annual Variance", "0.049"},
-            {"Information Ratio", "-14.565"},
-            {"Tracking Error", "0.001"},
-            {"Treynor Ratio", "1.97"},
-            {"Total Fees", "$3.44"},
-            {"Estimated Strategy Capacity", "$56000000.00"},
-            {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
-            {"Portfolio Turnover", "19.93%"},
-            {"OrderListHash", "3da9fa60bf95b9ed148b95e02e0cfc9e"}
+            {"Alpha", "0.007"},
+            {"Beta", "76.118"},
+            {"Annual Standard Deviation", "0.192"},
+            {"Annual Variance", "0.037"},
+            {"Information Ratio", "4.354"},
+            {"Tracking Error", "0.192"},
+            {"Treynor Ratio", "0.011"},
+            {"Total Fees", "$3.26"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateAxosAlgorithm.cs

@@ -1,118 +0,0 @@
-/*
- * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
- * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
-*/
-
-using QuantConnect.Data;
-using QuantConnect.Interfaces;
-using QuantConnect.Brokerages;
-using System.Collections.Generic;
-
-namespace QuantConnect.Algorithm.CSharp
-{
-    /// <summary>
-    /// 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 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.
-        /// </summary>
-        public override void Initialize()
-        {
-            SetStartDate(2013, 10, 07);
-            SetEndDate(2013, 10, 11);
-            SetCash(100000);
-
-            SetBrokerageModel(BrokerageName.Axos);
-            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="slice">Slice object keyed by symbol containing the stock data</param>
-        public override void OnData(Slice slice)
-        {
-            if (!Portfolio.Invested)
-            {
-                // will set 25% of our buying power with a market order
-                SetHoldings("SPY", 0.25m);
-
-                Debug("Purchased SPY!");
-            }
-        }
-
-        /// <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 List<Language> Languages { get; } = new() { Language.CSharp, Language.Python };
-
-        /// <summary>
-        /// Data Points count of all timeslices of algorithm
-        /// </summary>
-        public long DataPoints => 3901;
-
-        /// <summary>
-        /// Data Points count of the algorithm history
-        /// </summary>
-        public int AlgorithmHistoryDataPoints => 0;
-
-        /// <summary>
-        /// Final status of the algorithm
-        /// </summary>
-        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
-
-        /// <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 Orders", "1"},
-            {"Average Win", "0%"},
-            {"Average Loss", "0%"},
-            {"Compounding Annual Return", "39.143%"},
-            {"Drawdown", "0.500%"},
-            {"Expectancy", "0"},
-            {"Start Equity", "100000"},
-            {"End Equity", "100423.24"},
-            {"Net Profit", "0.423%"},
-            {"Sharpe Ratio", "5.498"},
-            {"Sortino Ratio", "0"},
-            {"Probabilistic Sharpe Ratio", "67.498%"},
-            {"Loss Rate", "0%"},
-            {"Win Rate", "0%"},
-            {"Profit-Loss Ratio", "0"},
-            {"Alpha", "0"},
-            {"Beta", "0"},
-            {"Annual Standard Deviation", "0.055"},
-            {"Annual Variance", "0.003"},
-            {"Information Ratio", "5.634"},
-            {"Tracking Error", "0.055"},
-            {"Treynor Ratio", "0"},
-            {"Total Fees", "$0.60"},
-            {"Estimated Strategy Capacity", "$150000000.00"},
-            {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
-            {"Portfolio Turnover", "4.98%"},
-            {"OrderListHash", "8774049eb5141a2b6956d9432426f837"}
-        };
-    }
-}

Algorithm.CSharp/BasicTemplateCfdAlgorithm.cs

@@ -1,72 +0,0 @@
-/*
- * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
- * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
-*/
-
-using System.Linq;
-using QuantConnect.Data;
-using QuantConnect.Orders;
-
-namespace QuantConnect.Algorithm.CSharp
-{
-    /// <summary>
-    /// Algorithm demonstrating CFD asset types and requesting history.
-    /// </summary>
-    /// <meta name="tag" content="using data" />
-    /// <meta name="tag" content="history" />
-    /// <meta name="tag" content="cfd" />
-    public class BasicTemplateCfdAlgorithm : QCAlgorithm
-    {
-        private Symbol _symbol;
-
-        /// <summary>
-        /// Initialise the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must initialized.
-        /// </summary>
-        public override void Initialize()
-        {
-            SetAccountCurrency("EUR");
-
-            SetStartDate(2019, 2, 20);
-            SetEndDate(2019, 2, 21);
-            SetCash("EUR", 100000);
-
-            _symbol = AddCfd("DE30EUR").Symbol;
-
-            // Historical Data
-            var history = History(_symbol, 60, Resolution.Daily);
-            Log($"Received {history.Count()} bars from CFD historical data call.");
-        }
-
-        /// <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 slice)
-        {
-            // Access Data
-            if (slice.QuoteBars.ContainsKey(_symbol))
-            {
-                var quoteBar = slice.QuoteBars[_symbol];
-                Log($"{quoteBar.EndTime} :: {quoteBar.Close}");
-            }
-
-            if (!Portfolio.Invested)
-                SetHoldings(_symbol, 1);
-        }
-
-        public override void OnOrderEvent(OrderEvent orderEvent)
-        {
-            Debug($"{Time} {orderEvent.ToString()}");
-        }
-    }
-}

Algorithm.CSharp/BasicTemplateContinuousFutureAlgorithm.cs

@@ -1,167 +0,0 @@
-/*
- * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
- * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
-*/
-
-using System;
-using QuantConnect.Data;
-using QuantConnect.Orders;
-using QuantConnect.Interfaces;
-using System.Collections.Generic;
-using System.Linq;
-using QuantConnect.Data.UniverseSelection;
-using QuantConnect.Indicators;
-using QuantConnect.Securities;
-using QuantConnect.Securities.Future;
-using Futures = QuantConnect.Securities.Futures;
-
-namespace QuantConnect.Algorithm.CSharp
-{
-    /// <summary>
-    /// Basic Continuous Futures Template Algorithm
-    /// </summary>
-    public class BasicTemplateContinuousFutureAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
-    {
-        private Future _continuousContract;
-        private Security _currentContract;
-        private SimpleMovingAverage _fast;
-        private SimpleMovingAverage _slow;
-
-        /// <summary>
-        /// Initialise the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must initialized.
-        /// </summary>
-        public override void Initialize()
-        {
-            SetStartDate(2013, 7, 1);
-            SetEndDate(2014, 1, 1);
-
-            _continuousContract = AddFuture(Futures.Indices.SP500EMini,
-                dataNormalizationMode: DataNormalizationMode.BackwardsRatio,
-                dataMappingMode: DataMappingMode.LastTradingDay,
-                contractDepthOffset: 0
-            );
-
-            _fast = SMA(_continuousContract.Symbol, 4, Resolution.Daily);
-            _slow = SMA(_continuousContract.Symbol, 10, Resolution.Daily);
-        }
-
-        /// <summary>
-        /// OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here.
-        /// </summary>
-        /// <param name="data">Slice object keyed by symbol containing the stock data</param>
-        public override void OnData(Slice slice)
-        {
-            foreach (var changedEvent in slice.SymbolChangedEvents.Values)
-            {
-                Debug($"{Time} - SymbolChanged event: {changedEvent}");
-                if (Time.TimeOfDay != TimeSpan.Zero)
-                {
-                    throw new RegressionTestException($"{Time} unexpected symbol changed event {changedEvent}!");
-                }
-            }
-
-            if (!Portfolio.Invested)
-            {
-                if(_fast > _slow)
-                {
-                    _currentContract = Securities[_continuousContract.Mapped];
-                    Buy(_currentContract.Symbol, 1);
-                }
-            }
-            else if(_fast < _slow)
-            {
-                Liquidate();
-            }
-
-            // We check exchange hours because the contract mapping can call OnData outside of regular hours.
-            if (_currentContract != null && _currentContract.Symbol != _continuousContract.Mapped && _continuousContract.Exchange.ExchangeOpen)
-            {
-                Log($"{Time} - rolling position from {_currentContract.Symbol} to {_continuousContract.Mapped}");
-
-                var currentPositionSize = _currentContract.Holdings.Quantity;
-                Liquidate(_currentContract.Symbol);
-                Buy(_continuousContract.Mapped, currentPositionSize);
-                _currentContract = Securities[_continuousContract.Mapped];
-            }
-        }
-
-        public override void OnOrderEvent(OrderEvent orderEvent)
-        {
-            Debug($"{orderEvent}");
-        }
-
-        public override void OnSecuritiesChanged(SecurityChanges changes)
-        {
-            Debug($"{Time}-{changes}");
-        }
-
-        /// <summary>
-        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
-        /// </summary>
-        public bool CanRunLocally { get; } = true;
-
-        /// <summary>
-        /// This is used by the regression test system to indicate which languages this algorithm is written in.
-        /// </summary>
-        public List<Language> Languages { get; } = new() { Language.CSharp, Language.Python };
-
-        /// <summary>
-        /// Data Points count of all timeslices of algorithm
-        /// </summary>
-        public long DataPoints => 713375;
-
-        /// <summary>
-        /// Data Points count of the algorithm history
-        /// </summary>
-        public int AlgorithmHistoryDataPoints => 0;
-
-        /// <summary>
-        /// Final status of the algorithm
-        /// </summary>
-        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
-
-        /// <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 Orders", "5"},
-            {"Average Win", "2.48%"},
-            {"Average Loss", "0%"},
-            {"Compounding Annual Return", "11.325%"},
-            {"Drawdown", "1.500%"},
-            {"Expectancy", "0"},
-            {"Start Equity", "100000"},
-            {"End Equity", "105549.6"},
-            {"Net Profit", "5.550%"},
-            {"Sharpe Ratio", "1.332"},
-            {"Sortino Ratio", "879.904"},
-            {"Probabilistic Sharpe Ratio", "79.894%"},
-            {"Loss Rate", "0%"},
-            {"Win Rate", "100%"},
-            {"Profit-Loss Ratio", "0"},
-            {"Alpha", "0.075"},
-            {"Beta", "-0.017"},
-            {"Annual Standard Deviation", "0.053"},
-            {"Annual Variance", "0.003"},
-            {"Information Ratio", "-1.48"},
-            {"Tracking Error", "0.099"},
-            {"Treynor Ratio", "-4.187"},
-            {"Total Fees", "$10.75"},
-            {"Estimated Strategy Capacity", "$7100000.00"},
-            {"Lowest Capacity Asset", "ES VMKLFZIH2MTD"},
-            {"Portfolio Turnover", "2.33%"},
-            {"OrderListHash", "9c524830ffc7354327638142ae62acd2"}
-        };
-    }
-}

Algorithm.CSharp/BasicTemplateContinuousFutureWithExtendedMarketAlgorithm.cs

@@ -1,172 +0,0 @@
-/*
- * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
- * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
-*/
-
-using System;
-using QuantConnect.Data;
-using QuantConnect.Orders;
-using QuantConnect.Interfaces;
-using System.Collections.Generic;
-using System.Linq;
-using QuantConnect.Data.UniverseSelection;
-using QuantConnect.Indicators;
-using QuantConnect.Securities;
-using QuantConnect.Securities.Future;
-using Futures = QuantConnect.Securities.Futures;
-
-namespace QuantConnect.Algorithm.CSharp
-{
-    /// <summary>
-    /// Basic Continuous Futures Template Algorithm with extended market hours
-    /// </summary>
-    public class BasicTemplateContinuousFutureWithExtendedMarketAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
-    {
-        private Future _continuousContract;
-        private Security _currentContract;
-        private SimpleMovingAverage _fast;
-        private SimpleMovingAverage _slow;
-
-        /// <summary>
-        /// Initialise the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must initialized.
-        /// </summary>
-        public override void Initialize()
-        {
-            SetStartDate(2013, 7, 1);
-            SetEndDate(2014, 1, 1);
-
-            _continuousContract = AddFuture(Futures.Indices.SP500EMini,
-                dataNormalizationMode: DataNormalizationMode.BackwardsRatio,
-                dataMappingMode: DataMappingMode.LastTradingDay,
-                contractDepthOffset: 0,
-                extendedMarketHours: true
-            );
-
-            _fast = SMA(_continuousContract.Symbol, 4, Resolution.Daily);
-            _slow = SMA(_continuousContract.Symbol, 10, Resolution.Daily);
-        }
-
-        /// <summary>
-        /// OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here.
-        /// </summary>
-        /// <param name="slice">Slice object keyed by symbol containing the stock data</param>
-        public override void OnData(Slice slice)
-        {
-            foreach (var changedEvent in slice.SymbolChangedEvents.Values)
-            {
-                Debug($"{Time} - SymbolChanged event: {changedEvent}");
-                if (Time.TimeOfDay != TimeSpan.Zero)
-                {
-                    throw new RegressionTestException($"{Time} unexpected symbol changed event {changedEvent}!");
-                }
-            }
-
-            if (!IsMarketOpen(_continuousContract.Symbol))
-            {
-                return;
-            }
-
-            if (!Portfolio.Invested)
-            {
-                if(_fast > _slow)
-                {
-                    _currentContract = Securities[_continuousContract.Mapped];
-                    Buy(_currentContract.Symbol, 1);
-                }
-            }
-            else if(_fast < _slow)
-            {
-                Liquidate();
-            }
-
-            if (_currentContract != null && _currentContract.Symbol != _continuousContract.Mapped)
-            {
-                Log($"{Time} - rolling position from {_currentContract.Symbol} to {_continuousContract.Mapped}");
-
-                var currentPositionSize = _currentContract.Holdings.Quantity;
-                Liquidate(_currentContract.Symbol);
-                Buy(_continuousContract.Mapped, currentPositionSize);
-                _currentContract = Securities[_continuousContract.Mapped];
-            }
-        }
-
-        public override void OnOrderEvent(OrderEvent orderEvent)
-        {
-            Debug($"{orderEvent}");
-        }
-
-        public override void OnSecuritiesChanged(SecurityChanges changes)
-        {
-            Debug($"{Time}-{changes}");
-        }
-
-        /// <summary>
-        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
-        /// </summary>
-        public bool CanRunLocally { get; } = true;
-
-        /// <summary>
-        /// This is used by the regression test system to indicate which languages this algorithm is written in.
-        /// </summary>
-        public List<Language> Languages { get; } = new() { Language.CSharp, Language.Python };
-
-        /// <summary>
-        /// Data Points count of all timeslices of algorithm
-        /// </summary>
-        public long DataPoints => 2217328;
-
-        /// <summary>
-        /// Data Points count of the algorithm history
-        /// </summary>
-        public int AlgorithmHistoryDataPoints => 0;
-
-        /// <summary>
-        /// Final status of the algorithm
-        /// </summary>
-        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
-
-        /// <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 Orders", "5"},
-            {"Average Win", "2.86%"},
-            {"Average Loss", "0%"},
-            {"Compounding Annual Return", "12.959%"},
-            {"Drawdown", "1.100%"},
-            {"Expectancy", "0"},
-            {"Start Equity", "100000"},
-            {"End Equity", "106337.1"},
-            {"Net Profit", "6.337%"},
-            {"Sharpe Ratio", "1.41"},
-            {"Sortino Ratio", "1.242"},
-            {"Probabilistic Sharpe Ratio", "77.992%"},
-            {"Loss Rate", "0%"},
-            {"Win Rate", "100%"},
-            {"Profit-Loss Ratio", "0"},
-            {"Alpha", "0.071"},
-            {"Beta", "0.054"},
-            {"Annual Standard Deviation", "0.059"},
-            {"Annual Variance", "0.003"},
-            {"Information Ratio", "-1.392"},
-            {"Tracking Error", "0.097"},
-            {"Treynor Ratio", "1.518"},
-            {"Total Fees", "$10.75"},
-            {"Estimated Strategy Capacity", "$890000000.00"},
-            {"Lowest Capacity Asset", "ES VMKLFZIH2MTD"},
-            {"Portfolio Turnover", "2.32%"},
-            {"OrderListHash", "f60fc7dcba2c1ff077afeb191aee5008"}
-        };
-    }
-}

Algorithm.CSharp/BasicTemplateCryptoAlgorithm.cs

@@ -79,8 +79,8 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here.
         /// </summary>
-        /// <param name="slice">Slice object keyed by symbol containing the stock data</param>
-        public override void OnData(Slice slice)
+        /// <param name="data">Slice object keyed by symbol containing the stock data</param>
+        public override void OnData(Slice data)
         {
             if (Portfolio.CashBook["EUR"].ConversionRate == 0
                 || Portfolio.CashBook["BTC"].ConversionRate == 0
@@ -92,7 +92,7 @@ namespace QuantConnect.Algorithm.CSharp
                 Log($"LTC conversion rate: {Portfolio.CashBook["LTC"].ConversionRate}");
                 Log($"ETH conversion rate: {Portfolio.CashBook["ETH"].ConversionRate}");
 
-                throw new RegressionTestException("Conversion rate is 0");
+                throw new Exception("Conversion rate is 0");
             }
             if (Time.Hour == 1 && Time.Minute == 0)
             {
@@ -196,55 +196,32 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// This is used by the regression test system to indicate which languages this algorithm is written in.
         /// </summary>
-        public List<Language> Languages { get; } = new() { Language.CSharp, Language.Python };
-
-        /// <summary>
-        /// Data Points count of all timeslices of algorithm
-        /// </summary>
-        public long DataPoints => 12965;
-
-        /// <summary>
-        /// Data Points count of the algorithm history
-        /// </summary>
-        public int AlgorithmHistoryDataPoints => 240;
-
-        /// <summary>
-        /// Final status of the algorithm
-        /// </summary>
-        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
+        public Language[] Languages { get; } = { Language.CSharp, Language.Python };
 
         /// <summary>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
         /// </summary>
         public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
-            {"Total Orders", "12"},
+            {"Total Trades", "10"},
             {"Average Win", "0%"},
-            {"Average Loss", "0%"},
-            {"Compounding Annual Return", "0%"},
-            {"Drawdown", "0%"},
-            {"Expectancy", "0"},
-            {"Start Equity", "31588.24"},
-            {"End Equity", "30866.71"},
-            {"Net Profit", "0%"},
-            {"Sharpe Ratio", "0"},
-            {"Sortino Ratio", "0"},
-            {"Probabilistic Sharpe Ratio", "0%"},
-            {"Loss Rate", "0%"},
+            {"Average Loss", "-0.13%"},
+            {"Compounding Annual Return", "-99.979%"},
+            {"Drawdown", "3.500%"},
+            {"Expectancy", "-1"},
+            {"Net Profit", "-2.288%"},
+            {"Sharpe Ratio", "-11.335"},
+            {"Loss Rate", "100%"},
             {"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", "$85.34"},
-            {"Estimated Strategy Capacity", "$0"},
-            {"Lowest Capacity Asset", "BTCEUR 2XR"},
-            {"Portfolio Turnover", "118.08%"},
-            {"OrderListHash", "26b9a07ace86b6a0e0eb2ff8c168cee0"}
+            {"Alpha", "-5.739"},
+            {"Beta", "413.859"},
+            {"Annual Standard Deviation", "0.254"},
+            {"Annual Variance", "0.065"},
+            {"Information Ratio", "-11.39"},
+            {"Tracking Error", "0.254"},
+            {"Treynor Ratio", "-0.007"},
+            {"Total Fees", "$85.34"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateCryptoFutureAlgorithm.cs

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

Algorithm.CSharp/BasicTemplateCryptoFutureHourlyAlgorithm.cs

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

Algorithm.CSharp/BasicTemplateDailyAlgorithm.cs

@@ -43,8 +43,8 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here.
         /// </summary>
-        /// <param name="slice">Slice object keyed by symbol containing the stock data</param>
-        public override void OnData(Slice slice)
+        /// <param name="data">Slice object keyed by symbol containing the stock data</param>
+        public override void OnData(Slice data)
         {
             if (!Portfolio.Invested)
             {
@@ -61,55 +61,32 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// This is used by the regression test system to indicate which languages this algorithm is written in.
         /// </summary>
-        public List<Language> Languages { get; } = new() { Language.CSharp, Language.Python };
-
-        /// <summary>
-        /// Data Points count of all timeslices of algorithm
-        /// </summary>
-        public long DataPoints => 72;
-
-        /// <summary>
-        /// Data Points count of the algorithm history
-        /// </summary>
-        public int AlgorithmHistoryDataPoints => 0;
-
-        /// <summary>
-        /// Final status of the algorithm
-        /// </summary>
-        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
+        public Language[] Languages { get; } = { Language.CSharp, Language.Python };
 
         /// <summary>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
         /// </summary>
         public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
-            {"Total Orders", "1"},
+            {"Total Trades", "1"},
             {"Average Win", "0%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "424.375%"},
-            {"Drawdown", "0.800%"},
+            {"Compounding Annual Return", "246.000%"},
+            {"Drawdown", "1.100%"},
             {"Expectancy", "0"},
-            {"Start Equity", "100000"},
-            {"End Equity", "104486.22"},
-            {"Net Profit", "4.486%"},
-            {"Sharpe Ratio", "17.304"},
-            {"Sortino Ratio", "35.217"},
-            {"Probabilistic Sharpe Ratio", "96.835%"},
+            {"Net Profit", "3.459%"},
+            {"Sharpe Ratio", "6.033"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "-0.249"},
-            {"Beta", "1.015"},
-            {"Annual Standard Deviation", "0.141"},
-            {"Annual Variance", "0.02"},
-            {"Information Ratio", "-19"},
-            {"Tracking Error", "0.011"},
-            {"Treynor Ratio", "2.403"},
-            {"Total Fees", "$3.49"},
-            {"Estimated Strategy Capacity", "$1200000000.00"},
-            {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
-            {"Portfolio Turnover", "10.01%"},
-            {"OrderListHash", "70f21e930175a2ec9d465b21edc1b6d9"}
+            {"Alpha", "0.696"},
+            {"Beta", "17.597"},
+            {"Annual Standard Deviation", "0.16"},
+            {"Annual Variance", "0.026"},
+            {"Information Ratio", "5.939"},
+            {"Tracking Error", "0.16"},
+            {"Treynor Ratio", "0.055"},
+            {"Total Fees", "$3.26"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateEurexFuturesAlgorithm.cs

@@ -1,239 +0,0 @@
-/*
- * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
- * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
-*/
-
-using System;
-using System.Collections.Generic;
-using QuantConnect.Data;
-using QuantConnect.Data.UniverseSelection;
-using QuantConnect.Interfaces;
-using QuantConnect.Orders;
-using QuantConnect.Securities;
-using QuantConnect.Securities.Future;
-
-namespace QuantConnect.Algorithm.CSharp
-{
-    /// <summary>
-    /// This algorithm tests and demonstrates EUREX futures subscription and trading:
-    /// - It tests contracts rollover by adding a continuous future and asserting that mapping happens at some point.
-    /// - It tests basic trading by buying a contract and holding it until expiration.
-    /// - It tests delisting and asserts the holdings are liquidated after that.
-    /// </summary>
-    public class BasicTemplateEurexFuturesAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
-    {
-        private Future _continuousContract;
-        private Symbol _mappedSymbol;
-        private Symbol _contractToTrade;
-        private int _mappingsCount;
-        private decimal _boughtQuantity;
-        private decimal _liquidatedQuantity;
-        private bool _delisted;
-
-        public override void Initialize()
-        {
-            SetStartDate(2024, 5, 30);
-            SetEndDate(2024, 6, 23);
-
-            SetAccountCurrency(Currencies.EUR);
-            SetCash(1000000);
-
-            _continuousContract = AddFuture(Futures.Indices.EuroStoxx50, Resolution.Minute,
-                dataNormalizationMode: DataNormalizationMode.BackwardsRatio,
-                dataMappingMode: DataMappingMode.FirstDayMonth,
-                contractDepthOffset: 0);
-            _continuousContract.SetFilter(TimeSpan.Zero, TimeSpan.FromDays(180));
-            _mappedSymbol = _continuousContract.Mapped;
-
-            var benchmark = AddIndex("SX5E", market: Market.EUREX);
-            SetBenchmark(benchmark.Symbol);
-
-            var seeder = new FuncSecuritySeeder(GetLastKnownPrices);
-            SetSecurityInitializer(security => seeder.SeedSecurity(security));
-        }
-
-        public override void OnData(Slice slice)
-        {
-            foreach (var changedEvent in slice.SymbolChangedEvents.Values)
-            {
-                if (++_mappingsCount > 1)
-                {
-                    throw new RegressionTestException($"{Time} - Unexpected number of symbol changed events (mappings): {_mappingsCount}. " +
-                        $"Expected only 1.");
-                }
-
-                Debug($"{Time} - SymbolChanged event: {changedEvent}");
-
-                if (changedEvent.OldSymbol != _mappedSymbol.ID.ToString())
-                {
-                    throw new RegressionTestException($"{Time} - Unexpected symbol changed event old symbol: {changedEvent}");
-                }
-
-                if (changedEvent.NewSymbol != _continuousContract.Mapped.ID.ToString())
-                {
-                    throw new RegressionTestException($"{Time} - Unexpected symbol changed event new symbol: {changedEvent}");
-                }
-
-                // Let's trade the previous mapped contract, so we can hold it until expiration for testing
-                // (will be sooner than the new mapped contract)
-                _contractToTrade = _mappedSymbol;
-                _mappedSymbol = _continuousContract.Mapped;
-            }
-
-            // Let's trade after the mapping is done
-            if (_contractToTrade != null && _boughtQuantity == 0 && Securities[_contractToTrade].Exchange.ExchangeOpen)
-            {
-                Buy(_contractToTrade, 1);
-            }
-
-            if (_contractToTrade != null && slice.Delistings.TryGetValue(_contractToTrade, out var delisting))
-            {
-                if (delisting.Type == DelistingType.Delisted)
-                {
-                    _delisted = true;
-
-                    if (Portfolio.Invested)
-                    {
-                        throw new RegressionTestException($"{Time} - Portfolio should not be invested after the traded contract is delisted.");
-                    }
-                }
-            }
-        }
-
-        public override void OnOrderEvent(OrderEvent orderEvent)
-        {
-            if (orderEvent.Symbol != _contractToTrade)
-            {
-                throw new RegressionTestException($"{Time} - Unexpected order event symbol: {orderEvent.Symbol}. Expected {_contractToTrade}");
-            }
-
-            if (orderEvent.Direction == OrderDirection.Buy)
-            {
-                if (orderEvent.Status == OrderStatus.Filled)
-                {
-                    if (_boughtQuantity != 0 && _liquidatedQuantity != 0)
-                    {
-                        throw new RegressionTestException($"{Time} - Unexpected buy order event status: {orderEvent.Status}");
-                    }
-                    _boughtQuantity = orderEvent.Quantity;
-                }
-            }
-            else if (orderEvent.Direction == OrderDirection.Sell)
-            {
-                if (orderEvent.Status == OrderStatus.Filled)
-                {
-                    if (_boughtQuantity <= 0 && _liquidatedQuantity != 0)
-                    {
-                        throw new RegressionTestException($"{Time} - Unexpected sell order event status: {orderEvent.Status}");
-                    }
-                    _liquidatedQuantity = orderEvent.Quantity;
-
-                    if (_liquidatedQuantity != -_boughtQuantity)
-                    {
-                        throw new RegressionTestException($"{Time} - Unexpected liquidated quantity: {_liquidatedQuantity}. Expected: {-_boughtQuantity}");
-                    }
-                }
-            }
-        }
-
-        public override void OnSecuritiesChanged(SecurityChanges changes)
-        {
-            foreach (var addedSecurity in changes.AddedSecurities)
-            {
-                if (addedSecurity.Symbol.SecurityType == SecurityType.Future && addedSecurity.Symbol.IsCanonical())
-                {
-                    _mappedSymbol = _continuousContract.Mapped;
-                }
-            }
-        }
-
-        public override void OnEndOfAlgorithm()
-        {
-            if (_mappingsCount == 0)
-            {
-                throw new RegressionTestException($"Unexpected number of symbol changed events (mappings): {_mappingsCount}. Expected 1.");
-            }
-
-            if (!_delisted)
-            {
-                throw new RegressionTestException("Contract was not delisted");
-            }
-
-            // Make sure we traded and that the position was liquidated on delisting
-            if (_boughtQuantity <= 0 || _liquidatedQuantity >= 0)
-            {
-                throw new RegressionTestException($"Unexpected sold quantity: {_boughtQuantity} and liquidated quantity: {_liquidatedQuantity}");
-            }
-        }
-
-        /// <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 List<Language> Languages { get; } = new() { Language.CSharp, Language.Python };
-
-        /// <summary>
-        /// Data Points count of all timeslices of algorithm
-        /// </summary>
-        public long DataPoints => 133947;
-
-        /// <summary>
-        /// Data Points count of the algorithm history
-        /// </summary>
-        public int AlgorithmHistoryDataPoints => 26;
-
-        /// <summary>
-        /// Final status of the algorithm
-        /// </summary>
-        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
-
-        /// <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 Orders", "2"},
-            {"Average Win", "0%"},
-            {"Average Loss", "-0.11%"},
-            {"Compounding Annual Return", "-1.667%"},
-            {"Drawdown", "0.100%"},
-            {"Expectancy", "-1"},
-            {"Start Equity", "1000000"},
-            {"End Equity", "998849.48"},
-            {"Net Profit", "-0.115%"},
-            {"Sharpe Ratio", "-34.455"},
-            {"Sortino Ratio", "-57.336"},
-            {"Probabilistic Sharpe Ratio", "0.002%"},
-            {"Loss Rate", "100%"},
-            {"Win Rate", "0%"},
-            {"Profit-Loss Ratio", "0"},
-            {"Alpha", "0"},
-            {"Beta", "0"},
-            {"Annual Standard Deviation", "0.002"},
-            {"Annual Variance", "0"},
-            {"Information Ratio", "-6.176"},
-            {"Tracking Error", "0.002"},
-            {"Treynor Ratio", "0"},
-            {"Total Fees", "€1.02"},
-            {"Estimated Strategy Capacity", "€2300000000.00"},
-            {"Lowest Capacity Asset", "FESX YJHOAMPYKRS5"},
-            {"Portfolio Turnover", "0.40%"},
-            {"OrderListHash", "54040d29a467becaedcf59d79323321b"}
-        };
-    }
-}

Algorithm.CSharp/BasicTemplateFillForwardAlgorithm.cs

@@ -13,7 +13,6 @@
  * limitations under the License.
 */
 
-using QuantConnect.Data;
 using QuantConnect.Data.Market;
 
 namespace QuantConnect.Algorithm.CSharp
@@ -42,8 +41,8 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here.
         /// </summary>
-        /// <param name="slice">Slice object keyed by symbol containing the stock data</param>
-        public override void OnData(Slice slice)
+        /// <param name="data">TradeBars IDictionary object with your stock data</param>
+        public void OnData(TradeBars data)
         {
             if (!Portfolio.Invested)
             {

Algorithm.CSharp/BasicTemplateForexAlgorithm.cs

@@ -1,4 +1,4 @@
-/*
+/*
  * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
  * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
  *
@@ -59,14 +59,14 @@ namespace QuantConnect.Algorithm.CSharp
         /// 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 slice)
+        public override void OnData(Slice data)
         {
             if (!Portfolio.Invested)
             {
                 SetHoldings("EURUSD", .5);
                 SetHoldings("NZDUSD", .5);
-                Log(string.Join(", ", slice.Values));
+                Log(string.Join(", ", data.Values));
             }
         }
     }
-}
+}

Algorithm.CSharp/BasicTemplateFrameworkAlgorithm.cs

@@ -53,15 +53,7 @@ namespace QuantConnect.Algorithm.CSharp
             // set algorithm framework models
             SetUniverseSelection(new ManualUniverseSelectionModel(QuantConnect.Symbol.Create("SPY", SecurityType.Equity, Market.USA)));
             SetAlpha(new ConstantAlphaModel(InsightType.Price, InsightDirection.Up, TimeSpan.FromMinutes(20), 0.025, null));
-
-            // We can define who often the EWPCM will rebalance if no new insight is submitted using:
-            // Resolution Enum:
-            SetPortfolioConstruction(new EqualWeightingPortfolioConstructionModel(Resolution.Daily));
-            // TimeSpan
-            // SetPortfolioConstruction(new EqualWeightingPortfolioConstructionModel(TimeSpan.FromDays(2)));
-            // A Func<DateTime, DateTime>. In this case, we can use the pre-defined func at Expiry helper class
-            // SetPortfolioConstruction(new EqualWeightingPortfolioConstructionModel(Expiry.EndOfWeek));
-
+            SetPortfolioConstruction(new EqualWeightingPortfolioConstructionModel());
             SetExecution(new ImmediateExecutionModel());
             SetRiskManagement(new MaximumDrawdownPercentPerSecurity(0.01m));
         }
@@ -82,55 +74,46 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// This is used by the regression test system to indicate which languages this algorithm is written in.
         /// </summary>
-        public virtual List<Language> Languages { get; } = new() { Language.CSharp, Language.Python };
-
-        /// <summary>
-        /// Data Points count of all timeslices of algorithm
-        /// </summary>
-        public long DataPoints => 3943;
-
-        /// <summary>
-        /// Data Points count of the algorithm history
-        /// </summary>
-        public int AlgorithmHistoryDataPoints => 0;
-
-        /// <summary>
-        /// Final status of the algorithm
-        /// </summary>
-        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
+        public Language[] Languages { get; } = { Language.CSharp, Language.Python };
 
         /// <summary>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
         /// </summary>
         public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
-            {"Total Orders", "3"},
+            {"Total Trades", "3"},
             {"Average Win", "0%"},
-            {"Average Loss", "-1.01%"},
-            {"Compounding Annual Return", "261.134%"},
-            {"Drawdown", "2.200%"},
+            {"Average Loss", "-1.03%"},
+            {"Compounding Annual Return", "245.167%"},
+            {"Drawdown", "2.300%"},
             {"Expectancy", "-1"},
-            {"Start Equity", "100000"},
-            {"End Equity", "101655.30"},
-            {"Net Profit", "1.655%"},
-            {"Sharpe Ratio", "8.472"},
-            {"Sortino Ratio", "0"},
-            {"Probabilistic Sharpe Ratio", "66.840%"},
+            {"Net Profit", "1.597%"},
+            {"Sharpe Ratio", "4.169"},
             {"Loss Rate", "100%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "-0.091"},
-            {"Beta", "1.006"},
-            {"Annual Standard Deviation", "0.224"},
-            {"Annual Variance", "0.05"},
-            {"Information Ratio", "-33.445"},
-            {"Tracking Error", "0.002"},
-            {"Treynor Ratio", "1.885"},
-            {"Total Fees", "$10.32"},
-            {"Estimated Strategy Capacity", "$27000000.00"},
-            {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
-            {"Portfolio Turnover", "59.86%"},
-            {"OrderListHash", "f209ed42701b0419858e0100595b40c0"}
+            {"Alpha", "0.007"},
+            {"Beta", "73.191"},
+            {"Annual Standard Deviation", "0.195"},
+            {"Annual Variance", "0.038"},
+            {"Information Ratio", "4.113"},
+            {"Tracking Error", "0.195"},
+            {"Treynor Ratio", "0.011"},
+            {"Total Fees", "$9.77"},
+            {"Fitness Score", "0.747"},
+            {"Total Insights Generated", "100"},
+            {"Total Insights Closed", "99"},
+            {"Total Insights Analysis Completed", "99"},
+            {"Long Insight Count", "100"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "$158418.3850"},
+            {"Total Accumulated Estimated Alpha Value", "$25522.9620"},
+            {"Mean Population Estimated Insight Value", "$257.8077"},
+            {"Mean Population Direction", "54.5455%"},
+            {"Mean Population Magnitude", "54.5455%"},
+            {"Rolling Averaged Population Direction", "59.8056%"},
+            {"Rolling Averaged Population Magnitude", "59.8056%"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateFutureOptionAlgorithm.cs

@@ -1,95 +0,0 @@
-/*
- * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
- * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
-*/
-
-using System;
-using System.Linq;
-using QuantConnect.Data;
-using QuantConnect.Orders;
-using QuantConnect.Securities;
-
-namespace QuantConnect.Algorithm.CSharp
-{
-    /// <summary>
-    /// Algorithm demonstrating FutureOption asset types and requesting history.
-    /// </summary>
-    /// <meta name="tag" content="using data" />
-    /// <meta name="tag" content="history" />
-    /// <meta name="tag" content="future option" />
-    public class BasicTemplateFutureOptionAlgorithm : QCAlgorithm
-    {
-        private Symbol _symbol;
-
-        /// <summary>
-        /// Initialise the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must initialized.
-        /// </summary>
-        public override void Initialize()
-        {
-            SetStartDate(2022, 1, 1);
-            SetEndDate(2022, 2, 1);
-            SetCash(100000);
-
-            var gold_futures = AddFuture(Futures.Metals.Gold, Resolution.Minute);
-            gold_futures.SetFilter(0, 180);
-            _symbol = gold_futures.Symbol;
-            AddFutureOption(_symbol, universe => universe.Strikes(-5, +5)
-                                                        .CallsOnly()
-                                                        .BackMonth()
-                                                        .OnlyApplyFilterAtMarketOpen());
-
-            // Historical Data
-            var history = History(_symbol, 60, Resolution.Daily);
-            Log($"Received {history.Count()} bars from {_symbol} FutureOption historical data call.");
-        }
-
-        /// <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 slice)
-        {
-            // Access Data
-            foreach(var kvp in slice.OptionChains)
-            {
-                var underlyingFutureContract = kvp.Key.Underlying;
-                var chain = kvp.Value;
-
-                if (chain.Count() == 0) continue;
-
-                foreach(var contract in chain)
-                {
-                    Log($@"Canonical Symbol: {kvp.Key}; 
-                        Contract: {contract}; 
-                        Right: {contract.Right}; 
-                        Expiry: {contract.Expiry}; 
-                        Bid price: {contract.BidPrice}; 
-                        Ask price: {contract.AskPrice}; 
-                        Implied Volatility: {contract.ImpliedVolatility}");
-                }
-
-                if (!Portfolio.Invested)
-                {
-                    var atmStrike = chain.OrderBy(x => Math.Abs(chain.Underlying.Price - x.Strike)).First().Strike;
-                    var selectedContract = chain.Where(x => x.Strike == atmStrike).OrderByDescending(x => x.Expiry).First();
-                    MarketOrder(selectedContract.Symbol, 1);
-                }
-            }
-        }
-
-        public override void OnOrderEvent(OrderEvent orderEvent)
-        {
-            Debug($"{Time} {orderEvent.ToString()}");
-        }
-    }
-}

Algorithm.CSharp/BasicTemplateFutureRolloverAlgorithm.cs

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

Algorithm.CSharp/BasicTemplateFuturesAlgorithm.cs

@@ -1,4 +1,4 @@
-/*
+/*
  * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
  * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
  *
@@ -18,10 +18,8 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using QuantConnect.Data;
-using QuantConnect.Data.UniverseSelection;
 using QuantConnect.Interfaces;
 using QuantConnect.Securities;
-using QuantConnect.Securities.Future;
 
 namespace QuantConnect.Algorithm.CSharp
 {
@@ -35,13 +33,13 @@ namespace QuantConnect.Algorithm.CSharp
     /// <meta name="tag" content="futures" />
     public class BasicTemplateFuturesAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
     {
-        private Symbol _contractSymbol;
-
         // S&P 500 EMini futures
         private const string RootSP500 = Futures.Indices.SP500EMini;
+        public Symbol SP500 = QuantConnect.Symbol.Create(RootSP500, SecurityType.Future, Market.USA);
 
         // Gold futures
         private const string RootGold = Futures.Metals.Gold;
+        public Symbol Gold = QuantConnect.Symbol.Create(RootGold, SecurityType.Future, Market.USA);
 
         /// <summary>
         /// Initialize your algorithm and add desired assets.
@@ -56,16 +54,11 @@ namespace QuantConnect.Algorithm.CSharp
             var futureGold = AddFuture(RootGold);
 
             // set our expiry filter for this futures chain
-            // SetFilter method accepts TimeSpan objects or integer for days.
-            // The following statements yield the same filtering criteria
             futureSP500.SetFilter(TimeSpan.Zero, TimeSpan.FromDays(182));
-            futureGold.SetFilter(0, 182);
+            futureGold.SetFilter(TimeSpan.Zero, TimeSpan.FromDays(182));
 
             var benchmark = AddEquity("SPY");
             SetBenchmark(benchmark.Symbol);
-
-            var seeder = new FuncSecuritySeeder(GetLastKnownPrices);
-            SetSecurityInitializer(security => seeder.SeedSecurity(security));
         }
 
         /// <summary>
@@ -74,15 +67,6 @@ namespace QuantConnect.Algorithm.CSharp
         /// <param name="slice">The current slice of data keyed by symbol string</param>
         public override void OnData(Slice slice)
         {
-            foreach (var changedEvent in slice.SymbolChangedEvents.Values)
-            {
-                Debug($"{Time} - SymbolChanged event: {changedEvent}");
-                if (Time.TimeOfDay != TimeSpan.Zero)
-                {
-                    throw new RegressionTestException($"{Time} unexpected symbol changed event {changedEvent}!");
-                }
-            }
-
             if (!Portfolio.Invested)
             {
                 foreach(var chain in slice.FutureChains)
@@ -97,8 +81,7 @@ namespace QuantConnect.Algorithm.CSharp
                     // if found, trade it
                     if (contract != null)
                     {
-                        _contractSymbol = contract.Symbol;
-                        MarketOrder(_contractSymbol, 1);
+                        MarketOrder(contract.Symbol, 1);
                     }
                 }
             }
@@ -108,34 +91,6 @@ namespace QuantConnect.Algorithm.CSharp
             }
         }
 
-        public override void OnEndOfAlgorithm()
-        {
-            // Get the margin requirements
-            var buyingPowerModel = Securities[_contractSymbol].BuyingPowerModel;
-            var futureMarginModel = buyingPowerModel as FutureMarginModel;
-            if (buyingPowerModel == null)
-            {
-                throw new RegressionTestException($"Invalid buying power model. Found: {buyingPowerModel.GetType().Name}. Expected: {nameof(FutureMarginModel)}");
-            }
-            var initialOvernight = futureMarginModel.InitialOvernightMarginRequirement;
-            var maintenanceOvernight = futureMarginModel.MaintenanceOvernightMarginRequirement;
-            var initialIntraday = futureMarginModel.InitialIntradayMarginRequirement;
-            var maintenanceIntraday = futureMarginModel.MaintenanceIntradayMarginRequirement;
-        }
-
-        public override void OnSecuritiesChanged(SecurityChanges changes)
-        {
-            foreach (var addedSecurity in changes.AddedSecurities)
-            {
-                if (addedSecurity.Symbol.SecurityType == SecurityType.Future
-                    && !addedSecurity.Symbol.IsCanonical()
-                    && !addedSecurity.HasData)
-                {
-                    throw new RegressionTestException($"Future contracts did not work up as expected: {addedSecurity.Symbol}");
-                }
-            }
-        }
-
         /// <summary>
         /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
         /// </summary>
@@ -144,55 +99,33 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// This is used by the regression test system to indicate which languages this algorithm is written in.
         /// </summary>
-        public List<Language> Languages { get; } = new() { Language.CSharp, Language.Python };
-
-        /// <summary>
-        /// Data Points count of all timeslices of algorithm
-        /// </summary>
-        public long DataPoints => 75403;
-
-        /// <summary>
-        /// Data Points count of the algorithm history
-        /// </summary>
-        public int AlgorithmHistoryDataPoints => 340;
-
-        /// <summary>
-        /// Final status of the algorithm
-        /// </summary>
-        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
+        public Language[] Languages { get; } = { Language.CSharp, Language.Python };
 
         /// <summary>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
         /// </summary>
         public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
-            {"Total Orders", "2700"},
+            {"Total Trades", "8220"},
             {"Average Win", "0.00%"},
             {"Average Loss", "0.00%"},
-            {"Compounding Annual Return", "-99.777%"},
-            {"Drawdown", "4.400%"},
-            {"Expectancy", "-0.724"},
-            {"Start Equity", "1000000"},
-            {"End Equity", "955700.5"},
-            {"Net Profit", "-4.430%"},
-            {"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.065"},
-            {"Beta", "0.128"},
-            {"Annual Standard Deviation", "0.031"},
-            {"Annual Variance", "0.001"},
-            {"Information Ratio", "-81.232"},
-            {"Tracking Error", "0.212"},
-            {"Treynor Ratio", "-7.677"},
-            {"Total Fees", "$6237.00"},
-            {"Estimated Strategy Capacity", "$14000.00"},
-            {"Lowest Capacity Asset", "GC VOFJUCDY9XNH"},
-            {"Portfolio Turnover", "9912.69%"},
-            {"OrderListHash", "6e0f767a46a54365287801295cf7bb75"}
+            {"Compounding Annual Return", "-100.000%"},
+            {"Drawdown", "13.500%"},
+            {"Expectancy", "-0.818"},
+            {"Net Profit", "-13.517%"},
+            {"Sharpe Ratio", "-29.354"},
+            {"Loss Rate", "89%"},
+            {"Win Rate", "11%"},
+            {"Profit-Loss Ratio", "0.69"},
+            {"Alpha", "-7.746"},
+            {"Beta", "-0.859"},
+            {"Annual Standard Deviation", "0.305"},
+            {"Annual Variance", "0.093"},
+            {"Information Ratio", "-24.985"},
+            {"Tracking Error", "0.414"},
+            {"Treynor Ratio", "10.413"},
+            {"Total Fees", "$15207.00"},
+            {"Fitness Score", "0.033"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateFuturesConsolidationAlgorithm.cs

@@ -1,4 +1,4 @@
-/*
+/*
  * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
  * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
  *
@@ -33,6 +33,7 @@ namespace QuantConnect.Algorithm.CSharp
     public class BasicTemplateFuturesConsolidationAlgorithm : QCAlgorithm
     {
         private const string RootSP500 = Futures.Indices.SP500EMini;
+        public Symbol SP500 = QuantConnect.Symbol.Create(RootSP500, SecurityType.Future, Market.USA);
         private HashSet<Symbol> _futureContracts = new HashSet<Symbol>();
 
         public override void Initialize()
@@ -42,11 +43,7 @@ namespace QuantConnect.Algorithm.CSharp
             SetCash(1000000);
 
             var futureSP500 = AddFuture(RootSP500);
-            // set our expiry filter for this future chain
-            // SetFilter method accepts TimeSpan objects or integer for days.
-            // The following statements yield the same filtering criteria
-            futureSP500.SetFilter(0, 182);
-            // futureSP500.SetFilter(TimeSpan.Zero, TimeSpan.FromDays(182));
+            futureSP500.SetFilter(TimeSpan.Zero, TimeSpan.FromDays(182));
 
             SetBenchmark(x => 0);
         }
@@ -77,4 +74,4 @@ namespace QuantConnect.Algorithm.CSharp
             Log(quoteBar.ToString());
         }
     }
-}
+}

Algorithm.CSharp/BasicTemplateFuturesDailyAlgorithm.cs

@@ -1,166 +0,0 @@
-/*
- * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
- * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
-*/
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using QuantConnect.Data;
-using QuantConnect.Interfaces;
-using QuantConnect.Orders;
-using QuantConnect.Securities;
-using QuantConnect.Securities.Future;
-
-namespace QuantConnect.Algorithm.CSharp
-{
-    /// <summary>
-    /// This example demonstrates how to add futures with daily resolution.
-    /// </summary>
-    /// <meta name="tag" content="using data" />
-    /// <meta name="tag" content="benchmarks" />
-    /// <meta name="tag" content="futures" />
-    public class BasicTemplateFuturesDailyAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
-    {
-        protected virtual Resolution Resolution => Resolution.Daily;
-        protected virtual bool ExtendedMarketHours => false;
-
-        // S&P 500 EMini futures
-        private const string RootSP500 = Futures.Indices.SP500EMini;
-
-        // Gold futures
-        private const string RootGold = Futures.Metals.Gold;
-        private Future _futureSP500;
-        private Future _futureGold;
-
-        /// <summary>
-        /// Initialize your algorithm and add desired assets.
-        /// </summary>
-        public override void Initialize()
-        {
-            SetStartDate(2013, 10, 08);
-            SetEndDate(2014, 10, 10);
-            SetCash(1000000);
-
-            _futureSP500 = AddFuture(RootSP500, Resolution, extendedMarketHours: ExtendedMarketHours);
-            _futureGold = AddFuture(RootGold, Resolution, extendedMarketHours: ExtendedMarketHours);
-
-            // set our expiry filter for this futures chain
-            // SetFilter method accepts TimeSpan objects or integer for days.
-            // The following statements yield the same filtering criteria
-            _futureSP500.SetFilter(TimeSpan.Zero, TimeSpan.FromDays(182));
-            _futureGold.SetFilter(0, 182);
-        }
-
-        /// <summary>
-        /// Event - v3.0 DATA EVENT HANDLER: (Pattern) Basic template for user to override for receiving all subscription data in a single event
-        /// </summary>
-        /// <param name="slice">The current slice of data keyed by symbol string</param>
-        public override void OnData(Slice slice)
-        {
-            if (!Portfolio.Invested)
-            {
-                foreach(var chain in slice.FutureChains)
-                {
-                    // find the front contract expiring no earlier than in 90 days
-                    var contract = (
-                        from futuresContract in chain.Value.OrderBy(x => x.Expiry)
-                        where futuresContract.Expiry > Time.Date.AddDays(90)
-                        select futuresContract
-                    ).FirstOrDefault();
-
-                    // if found, trade it.
-                    // Also check if exchange is open for regular or extended hours. Since daily data comes at 8PM, this allows us prevent the
-                    // algorithm from trading on friday when there is not after-market.
-                    if (contract != null)
-                    {
-                        MarketOrder(contract.Symbol, 1);
-                    }
-                }
-            }
-            // Same as above, check for cases like trading on a friday night.
-            else if (Securities.Values.Where(x => x.Invested).All(x => x.Exchange.Hours.IsOpen(Time, true)))
-            {
-                Liquidate();
-            }
-
-            foreach (var changedEvent in slice.SymbolChangedEvents.Values)
-            {
-                if (Time.TimeOfDay != TimeSpan.Zero)
-                {
-                    throw new RegressionTestException($"{Time} unexpected symbol changed event {changedEvent}!");
-                }
-            }
-        }
-
-        /// <summary>
-        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
-        /// </summary>
-        public virtual bool CanRunLocally { get; } = true;
-
-        /// <summary>
-        /// This is used by the regression test system to indicate which languages this algorithm is written in.
-        /// </summary>
-        public virtual List<Language> Languages { get; } = new() { Language.CSharp, Language.Python };
-
-        /// <summary>
-        /// Data Points count of all timeslices of algorithm
-        /// </summary>
-        public virtual long DataPoints => 12455;
-
-        /// <summary>
-        /// Data Points count of the algorithm history
-        /// </summary>
-        public virtual int AlgorithmHistoryDataPoints => 0;
-
-        /// <summary>
-        /// Final status of the algorithm
-        /// </summary>
-        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
-
-        /// <summary>
-        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
-        /// </summary>
-        public virtual Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
-        {
-            {"Total Orders", "34"},
-            {"Average Win", "0.33%"},
-            {"Average Loss", "-0.04%"},
-            {"Compounding Annual Return", "0.106%"},
-            {"Drawdown", "0.300%"},
-            {"Expectancy", "0.178"},
-            {"Start Equity", "1000000"},
-            {"End Equity", "1001066.2"},
-            {"Net Profit", "0.107%"},
-            {"Sharpe Ratio", "-1.695"},
-            {"Sortino Ratio", "-0.804"},
-            {"Probabilistic Sharpe Ratio", "14.797%"},
-            {"Loss Rate", "88%"},
-            {"Win Rate", "12%"},
-            {"Profit-Loss Ratio", "9.01"},
-            {"Alpha", "-0.007"},
-            {"Beta", "0.002"},
-            {"Annual Standard Deviation", "0.004"},
-            {"Annual Variance", "0"},
-            {"Information Ratio", "-1.353"},
-            {"Tracking Error", "0.089"},
-            {"Treynor Ratio", "-4.112"},
-            {"Total Fees", "$76.30"},
-            {"Estimated Strategy Capacity", "$0"},
-            {"Lowest Capacity Asset", "ES VRJST036ZY0X"},
-            {"Portfolio Turnover", "0.92%"},
-            {"OrderListHash", "7afa589d648c3f24253cd59156a2014e"}
-        };
-    }
-}

Algorithm.CSharp/BasicTemplateFuturesFrameworkAlgorithm.cs

@@ -31,12 +31,9 @@ namespace QuantConnect.Algorithm.CSharp
     /// </summary>
     public class BasicTemplateFuturesFrameworkAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
     {
-        protected virtual bool ExtendedMarketHours => false;
-
         public override void Initialize()
         {
             UniverseSettings.Resolution = Resolution.Minute;
-            UniverseSettings.ExtendedMarketHours = ExtendedMarketHours;
 
             SetStartDate(2013, 10, 07);
             SetEndDate(2013, 10, 11);
@@ -56,12 +53,12 @@ namespace QuantConnect.Algorithm.CSharp
             var newYorkTime = utcTime.ConvertFromUtc(TimeZones.NewYork);
             if (newYorkTime.Date < new DateTime(2013, 10, 09))
             {
-                yield return QuantConnect.Symbol.Create(Futures.Indices.SP500EMini, SecurityType.Future, Market.CME);
+                yield return QuantConnect.Symbol.Create(Futures.Indices.SP500EMini, SecurityType.Future, Market.USA);
             }
 
             if (newYorkTime.Date >= new DateTime(2013, 10, 09))
             {
-                yield return QuantConnect.Symbol.Create(Futures.Metals.Gold, SecurityType.Future, Market.COMEX);
+                yield return QuantConnect.Symbol.Create(Futures.Metals.Gold, SecurityType.Future, Market.USA);
             }
         }
 
@@ -126,60 +123,50 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
         /// </summary>
-        public virtual bool CanRunLocally { get; } = true;
+        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 List<Language> Languages { get; } = new() { Language.CSharp, Language.Python };
-
-        /// <summary>
-        /// Data Points count of all timeslices of algorithm
-        /// </summary>
-        public virtual long DataPoints => 57759;
-
-        /// <summary>
-        /// Data Points count of the algorithm history
-        /// </summary>
-        public virtual int AlgorithmHistoryDataPoints => 0;
-
-        /// <summary>
-        /// Final status of the algorithm
-        /// </summary>
-        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
+        public Language[] Languages { get; } = { Language.CSharp, Language.Python };
 
         /// <summary>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
         /// </summary>
-        public virtual Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
-            {"Total Orders", "2"},
+            {"Total Trades", "2"},
             {"Average Win", "0%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "-81.734%"},
-            {"Drawdown", "4.100%"},
+            {"Compounding Annual Return", "-92.656%"},
+            {"Drawdown", "5.000%"},
             {"Expectancy", "0"},
-            {"Start Equity", "100000"},
-            {"End Equity", "97830.76"},
-            {"Net Profit", "-2.169%"},
-            {"Sharpe Ratio", "-10.299"},
-            {"Sortino Ratio", "-10.299"},
-            {"Probabilistic Sharpe Ratio", "0%"},
+            {"Net Profit", "-3.312%"},
+            {"Sharpe Ratio", "-16.986"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"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.109"},
-            {"Total Fees", "$4.62"},
-            {"Estimated Strategy Capacity", "$17000000.00"},
-            {"Lowest Capacity Asset", "GC VL5E74HP3EE5"},
-            {"Portfolio Turnover", "43.23%"},
-            {"OrderListHash", "c0fc1bcdc3008a8d263521bbc9d7cdbd"}
+            {"Alpha", "-0.828"},
+            {"Beta", "-77.873"},
+            {"Annual Standard Deviation", "0.099"},
+            {"Annual Variance", "0.01"},
+            {"Information Ratio", "-17.076"},
+            {"Tracking Error", "0.099"},
+            {"Treynor Ratio", "0.022"},
+            {"Total Fees", "$3.70"},
+            {"Total Insights Generated", "6"},
+            {"Total Insights Closed", "5"},
+            {"Total Insights Analysis Completed", "5"},
+            {"Long Insight Count", "6"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "$-96.12923"},
+            {"Total Accumulated Estimated Alpha Value", "$-15.621"},
+            {"Mean Population Estimated Insight Value", "$-3.1242"},
+            {"Mean Population Direction", "0%"},
+            {"Mean Population Magnitude", "0%"},
+            {"Rolling Averaged Population Direction", "0%"},
+            {"Rolling Averaged Population Magnitude", "0%"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateFuturesFrameworkWithExtendedMarketAlgorithm.cs

@@ -1,80 +0,0 @@
-/*
- * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
- * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
-*/
-
-using System;
-using System.Collections.Generic;
-using QuantConnect.Algorithm.Framework.Alphas;
-using QuantConnect.Algorithm.Framework.Execution;
-using QuantConnect.Algorithm.Framework.Portfolio;
-using QuantConnect.Algorithm.Framework.Risk;
-using QuantConnect.Algorithm.Framework.Selection;
-using QuantConnect.Interfaces;
-using QuantConnect.Securities;
-
-namespace QuantConnect.Algorithm.CSharp
-{
-    /// <summary>
-    /// Basic template futures framework algorithm uses framework components to define an algorithm
-    /// that trades futures.
-    /// </summary>
-    public class BasicTemplateFuturesFrameworkWithExtendedMarketAlgorithm : BasicTemplateFuturesFrameworkAlgorithm
-    {
-        protected override bool ExtendedMarketHours => true;
-
-        /// <summary>
-        /// This is used by the regression test system to indicate which languages this algorithm is written in.
-        /// </summary>
-        public override List<Language> Languages { get; } = new() { Language.CSharp, Language.Python };
-
-        /// <summary>
-        /// Data Points count of all timeslices of algorithm
-        /// </summary>
-        public override long DataPoints => 163416;
-
-        /// <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 Orders", "2"},
-            {"Average Win", "0%"},
-            {"Average Loss", "0%"},
-            {"Compounding Annual Return", "-92.667%"},
-            {"Drawdown", "5.000%"},
-            {"Expectancy", "0"},
-            {"Start Equity", "100000"},
-            {"End Equity", "96685.76"},
-            {"Net Profit", "-3.314%"},
-            {"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.47"},
-            {"Beta", "0.312"},
-            {"Annual Standard Deviation", "0.134"},
-            {"Annual Variance", "0.018"},
-            {"Information Ratio", "-14.77"},
-            {"Tracking Error", "0.192"},
-            {"Treynor Ratio", "-2.742"},
-            {"Total Fees", "$4.62"},
-            {"Estimated Strategy Capacity", "$52000000.00"},
-            {"Lowest Capacity Asset", "GC VL5E74HP3EE5"},
-            {"Portfolio Turnover", "43.77%"},
-            {"OrderListHash", "dcdaafcefa47465962ace2759ed99c91"}
-        };
-    }
-}

Algorithm.CSharp/BasicTemplateFuturesHistoryAlgorithm.cs

@@ -1,4 +1,4 @@
-/*
+/*
  * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
  * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
  *
@@ -20,8 +20,6 @@ using QuantConnect.Data;
 using QuantConnect.Orders;
 using QuantConnect.Securities;
 using QuantConnect.Data.UniverseSelection;
-using QuantConnect.Interfaces;
-using System.Collections.Generic;
 
 namespace QuantConnect.Algorithm.CSharp
 {
@@ -34,11 +32,8 @@ namespace QuantConnect.Algorithm.CSharp
     /// <meta name="tag" content="history and warm up" />
     /// <meta name="tag" content="history" />
     /// <meta name="tag" content="futures" />
-    public class BasicTemplateFuturesHistoryAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    public class BasicTemplateFuturesHistoryAlgorithm : QCAlgorithm
     {
-        protected virtual bool ExtendedMarketHours => false;
-        protected virtual int ExpectedHistoryCallCount => 42;
-
         // S&P 500 EMini futures
         private string [] roots = new []
         {
@@ -46,7 +41,6 @@ namespace QuantConnect.Algorithm.CSharp
             Futures.Metals.Gold,
         };
 
-        private int _successCount = 0;
         public override void Initialize()
         {
             SetStartDate(2013, 10, 8);
@@ -56,30 +50,10 @@ namespace QuantConnect.Algorithm.CSharp
             foreach (var root in roots)
             {
                 // set our expiry filter for this futures chain
-                AddFuture(root, Resolution.Minute, extendedMarketHours: ExtendedMarketHours).SetFilter(TimeSpan.Zero, TimeSpan.FromDays(182));
+                AddFuture(root, Resolution.Minute).SetFilter(TimeSpan.Zero, TimeSpan.FromDays(182));
             }
 
             SetBenchmark(d => 1000000);
-
-            Schedule.On(DateRules.EveryDay(), TimeRules.Every(TimeSpan.FromHours(1)), MakeHistoryCall);
-        }
-
-        private void MakeHistoryCall()
-        {
-            var history = History(10, Resolution.Minute);
-            if (history.Count() < 10)
-            {
-                throw new RegressionTestException($"Empty history at {Time}");
-            }
-            _successCount++;
-        }
-
-        public override void OnEndOfAlgorithm()
-        {
-            if (_successCount < ExpectedHistoryCallCount)
-            {
-                throw new RegressionTestException($"Scheduled Event did not assert history call as many times as expected: {_successCount}/49");
-            }
         }
 
         /// <summary>
@@ -94,12 +68,12 @@ namespace QuantConnect.Algorithm.CSharp
                 {
                     foreach (var contract in chain.Value)
                     {
-                        Log($"{contract.Symbol.Value}," +
-                            $"Bid={contract.BidPrice.ToStringInvariant()} " +
-                            $"Ask={contract.AskPrice.ToStringInvariant()} " +
-                            $"Last={contract.LastPrice.ToStringInvariant()} " +
-                            $"OI={contract.OpenInterest.ToStringInvariant()}"
-                        );
+                        Log(String.Format("{0},Bid={1} Ask={2} Last={3} OI={4}",
+                             contract.Symbol.Value,
+                             contract.BidPrice,
+                             contract.AskPrice,
+                             contract.LastPrice,
+                             contract.OpenInterest));
                     }
                 }
             }
@@ -120,70 +94,11 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Order fill event handler. On an order fill update the resulting information is passed to this method.
         /// </summary>
-        /// <param name="orderEvent">Order event details containing details of the events</param>
+        /// <param name="orderEvent">Order event details containing details of the evemts</param>
         /// <remarks>This method can be called asynchronously and so should only be used by seasoned C# experts. Ensure you use proper locks on thread-unsafe objects</remarks>
         public override void OnOrderEvent(OrderEvent orderEvent)
         {
             Log(orderEvent.ToString());
         }
-
-        /// <summary>
-        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
-        /// </summary>
-        public virtual bool CanRunLocally { get; } = true;
-
-        /// <summary>
-        /// This is used by the regression test system to indicate which languages this algorithm is written in.
-        /// </summary>
-        public virtual List<Language> Languages { get; } = new() { Language.CSharp, Language.Python };
-
-        /// <summary>
-        /// Data Points count of all timeslices of algorithm
-        /// </summary>
-        public virtual long DataPoints => 48690;
-
-        /// <summary>
-        /// Data Points count of the algorithm history
-        /// </summary>
-        public virtual int AlgorithmHistoryDataPoints => 5305;
-
-        /// <summary>
-        /// Final status of the algorithm
-        /// </summary>
-        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
-
-        /// <summary>
-        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
-        /// </summary>
-        public virtual Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
-        {
-            {"Total Orders", "0"},
-            {"Average Win", "0%"},
-            {"Average Loss", "0%"},
-            {"Compounding Annual Return", "0%"},
-            {"Drawdown", "0%"},
-            {"Expectancy", "0"},
-            {"Start Equity", "1000000"},
-            {"End Equity", "1000000"},
-            {"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/BasicTemplateFuturesHistoryWithExtendedMarketHoursAlgorithm.cs

@@ -1,96 +0,0 @@
-/*
- * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
- * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
-*/
-
-using System;
-using System.Linq;
-using QuantConnect.Data;
-using QuantConnect.Orders;
-using QuantConnect.Securities;
-using QuantConnect.Data.UniverseSelection;
-using QuantConnect.Interfaces;
-using System.Collections.Generic;
-
-namespace QuantConnect.Algorithm.CSharp
-{
-    /// <summary>
-    /// This example demonstrates how to get access to futures history for a given root symbol with extended market hours.
-    /// It also shows how you can prefilter contracts easily based on expirations, and inspect the futures
-    /// chain to pick a specific contract to trade.
-    /// </summary>
-    /// <meta name="tag" content="using data" />
-    /// <meta name="tag" content="history and warm up" />
-    /// <meta name="tag" content="history" />
-    /// <meta name="tag" content="futures" />
-    public class BasicTemplateFuturesHistoryWithExtendedMarketHoursAlgorithm : BasicTemplateFuturesHistoryAlgorithm
-    {
-        protected override bool ExtendedMarketHours => true;
-        protected override int ExpectedHistoryCallCount => 49;
-
-        /// <summary>
-        /// This is used by the regression test system to indicate which languages this algorithm is written in.
-        /// </summary>
-        public override List<Language> Languages { get; } = new() { Language.CSharp, Language.Python };
-
-        /// <summary>
-        /// Data Points count of all timeslices of algorithm
-        /// </summary>
-        public override long DataPoints => 147771;
-
-        /// <summary>
-        /// Data Points count of the algorithm history
-        /// </summary>
-        public override int AlgorithmHistoryDataPoints => 6112;
-
-        /// <summary>
-        /// Final status of the algorithm
-        /// </summary>
-        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
-
-        /// <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 Orders", "0"},
-            {"Average Win", "0%"},
-            {"Average Loss", "0%"},
-            {"Compounding Annual Return", "0%"},
-            {"Drawdown", "0%"},
-            {"Expectancy", "0"},
-            {"Start Equity", "1000000"},
-            {"End Equity", "1000000"},
-            {"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/BasicTemplateFuturesHourlyAlgorithm.cs

@@ -1,80 +0,0 @@
-/*
- * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
- * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
-*/
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using QuantConnect.Data;
-using QuantConnect.Interfaces;
-using QuantConnect.Securities;
-
-namespace QuantConnect.Algorithm.CSharp
-{
-    /// <summary>
-    /// This regressions tests the BasicTemplateFuturesDailyAlgorithm with hour data
-    /// </summary>
-    /// <meta name="tag" content="using data" />
-    /// <meta name="tag" content="benchmarks" />
-    /// <meta name="tag" content="futures" />
-    public class BasicTemplateFuturesHourlyAlgorithm : BasicTemplateFuturesDailyAlgorithm
-    {
-        protected override Resolution Resolution => Resolution.Hour;
-
-        /// <summary>
-        /// This is used by the regression test system to indicate which languages this algorithm is written in.
-        /// </summary>
-        public override List<Language> Languages { get; } = new() { Language.CSharp, Language.Python };
-
-        /// <summary>
-        /// Data Points count of all timeslices of algorithm
-        /// </summary>
-        public override long DataPoints => 87292;
-
-        /// <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 Orders", "716"},
-            {"Average Win", "0.03%"},
-            {"Average Loss", "-0.01%"},
-            {"Compounding Annual Return", "-1.716%"},
-            {"Drawdown", "1.700%"},
-            {"Expectancy", "-0.770"},
-            {"Start Equity", "1000000"},
-            {"End Equity", "982718.38"},
-            {"Net Profit", "-1.728%"},
-            {"Sharpe Ratio", "-8.845"},
-            {"Sortino Ratio", "-5.449"},
-            {"Probabilistic Sharpe Ratio", "0.000%"},
-            {"Loss Rate", "96%"},
-            {"Win Rate", "4%"},
-            {"Profit-Loss Ratio", "4.89"},
-            {"Alpha", "-0.018"},
-            {"Beta", "-0.002"},
-            {"Annual Standard Deviation", "0.002"},
-            {"Annual Variance", "0"},
-            {"Information Ratio", "-1.483"},
-            {"Tracking Error", "0.089"},
-            {"Treynor Ratio", "9.102"},
-            {"Total Fees", "$1634.12"},
-            {"Estimated Strategy Capacity", "$8000.00"},
-            {"Lowest Capacity Asset", "ES VP274HSU1AF5"},
-            {"Portfolio Turnover", "20.10%"},
-            {"OrderListHash", "aa7e574f86b70428ca0afae381be80ba"}
-        };
-    }
-}

Algorithm.CSharp/BasicTemplateFuturesWithExtendedMarketAlgorithm.cs

@@ -1,198 +0,0 @@
-/*
- * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
- * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
-*/
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using QuantConnect.Data;
-using QuantConnect.Data.UniverseSelection;
-using QuantConnect.Interfaces;
-using QuantConnect.Securities;
-using QuantConnect.Securities.Future;
-
-namespace QuantConnect.Algorithm.CSharp
-{
-    /// <summary>
-    /// This example demonstrates how to add futures for a given underlying asset.
-    /// It also shows how you can prefilter contracts easily based on expirations, and how you
-    /// can inspect the futures chain to pick a specific contract to trade.
-    /// </summary>
-    /// <meta name="tag" content="using data" />
-    /// <meta name="tag" content="benchmarks" />
-    /// <meta name="tag" content="futures" />
-    public class BasicTemplateFuturesWithExtendedMarketAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
-    {
-        private Symbol _contractSymbol;
-
-        // S&P 500 EMini futures
-        private const string RootSP500 = Futures.Indices.SP500EMini;
-
-        // Gold futures
-        private const string RootGold = Futures.Metals.Gold;
-
-        /// <summary>
-        /// Initialize your algorithm and add desired assets.
-        /// </summary>
-        public override void Initialize()
-        {
-            SetStartDate(2013, 10, 08);
-            SetEndDate(2013, 10, 10);
-            SetCash(1000000);
-
-            var futureSP500 = AddFuture(RootSP500, extendedMarketHours: true);
-            var futureGold = AddFuture(RootGold, extendedMarketHours: true);
-
-            // set our expiry filter for this futures chain
-            // SetFilter method accepts TimeSpan objects or integer for days.
-            // The following statements yield the same filtering criteria
-            futureSP500.SetFilter(TimeSpan.Zero, TimeSpan.FromDays(182));
-            futureGold.SetFilter(0, 182);
-
-            var benchmark = AddEquity("SPY");
-            SetBenchmark(benchmark.Symbol);
-
-            var seeder = new FuncSecuritySeeder(GetLastKnownPrices);
-            SetSecurityInitializer(security => seeder.SeedSecurity(security));
-        }
-
-        /// <summary>
-        /// Event - v3.0 DATA EVENT HANDLER: (Pattern) Basic template for user to override for receiving all subscription data in a single event
-        /// </summary>
-        /// <param name="slice">The current slice of data keyed by symbol string</param>
-        public override void OnData(Slice slice)
-        {
-            foreach (var changedEvent in slice.SymbolChangedEvents.Values)
-            {
-                Debug($"{Time} - SymbolChanged event: {changedEvent}");
-                if (Time.TimeOfDay != TimeSpan.Zero)
-                {
-                    throw new RegressionTestException($"{Time} unexpected symbol changed event {changedEvent}!");
-                }
-            }
-
-            if (!Portfolio.Invested)
-            {
-                foreach(var chain in slice.FutureChains)
-                {
-                    // find the front contract expiring no earlier than in 90 days
-                    var contract = (
-                        from futuresContract in chain.Value.OrderBy(x => x.Expiry)
-                        where futuresContract.Expiry > Time.Date.AddDays(90)
-                        select futuresContract
-                    ).FirstOrDefault();
-
-                    // if found, trade it
-                    if (contract != null)
-                    {
-                        _contractSymbol = contract.Symbol;
-                        MarketOrder(_contractSymbol, 1);
-                    }
-                }
-            }
-            else
-            {
-                Liquidate();
-            }
-        }
-
-        public override void OnEndOfAlgorithm()
-        {
-            // Get the margin requirements
-            var buyingPowerModel = Securities[_contractSymbol].BuyingPowerModel;
-            var futureMarginModel = buyingPowerModel as FutureMarginModel;
-            if (buyingPowerModel == null)
-            {
-                throw new RegressionTestException($"Invalid buying power model. Found: {buyingPowerModel.GetType().Name}. Expected: {nameof(FutureMarginModel)}");
-            }
-            var initialOvernight = futureMarginModel.InitialOvernightMarginRequirement;
-            var maintenanceOvernight = futureMarginModel.MaintenanceOvernightMarginRequirement;
-            var initialIntraday = futureMarginModel.InitialIntradayMarginRequirement;
-            var maintenanceIntraday = futureMarginModel.MaintenanceIntradayMarginRequirement;
-        }
-
-        public override void OnSecuritiesChanged(SecurityChanges changes)
-        {
-            foreach (var addedSecurity in changes.AddedSecurities)
-            {
-                if (addedSecurity.Symbol.SecurityType == SecurityType.Future
-                    && !addedSecurity.Symbol.IsCanonical()
-                    && !addedSecurity.HasData)
-                {
-                    throw new RegressionTestException($"Future contracts did not work up as expected: {addedSecurity.Symbol}");
-                }
-            }
-        }
-
-        /// <summary>
-        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
-        /// </summary>
-        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 List<Language> Languages { get; } = new() { Language.CSharp, Language.Python };
-
-        /// <summary>
-        /// Data Points count of all timeslices of algorithm
-        /// </summary>
-        public long DataPoints => 224662;
-
-        /// <summary>
-        /// Data Points count of the algorithm history
-        /// </summary>
-        public int AlgorithmHistoryDataPoints => 340;
-
-        /// <summary>
-        /// Final status of the algorithm
-        /// </summary>
-        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
-
-        /// <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 Orders", "8282"},
-            {"Average Win", "0.00%"},
-            {"Average Loss", "0.00%"},
-            {"Compounding Annual Return", "-100.000%"},
-            {"Drawdown", "13.900%"},
-            {"Expectancy", "-0.824"},
-            {"Start Equity", "1000000"},
-            {"End Equity", "861260.7"},
-            {"Net Profit", "-13.874%"},
-            {"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.468"},
-            {"Beta", "-0.215"},
-            {"Annual Standard Deviation", "0.052"},
-            {"Annual Variance", "0.003"},
-            {"Information Ratio", "-58.37"},
-            {"Tracking Error", "0.295"},
-            {"Treynor Ratio", "4.695"},
-            {"Total Fees", "$19131.42"},
-            {"Estimated Strategy Capacity", "$130000.00"},
-            {"Lowest Capacity Asset", "GC VOFJUCDY9XNH"},
-            {"Portfolio Turnover", "32523.20%"},
-            {"OrderListHash", "0664a72652a19956ea3c4915269cc4b9"}
-        };
-    }
-}

Algorithm.CSharp/BasicTemplateFuturesWithExtendedMarketDailyAlgorithm.cs

@@ -1,75 +0,0 @@
-/*
- * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
- * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
-*/
-
-using System.Collections.Generic;
-
-namespace QuantConnect.Algorithm.CSharp
-{
-    /// <summary>
-    /// This example demonstrates how to add futures with daily resolution and extended market hours.
-    /// </summary>
-    /// <meta name="tag" content="using data" />
-    /// <meta name="tag" content="benchmarks" />
-    /// <meta name="tag" content="futures" />
-    public class BasicTemplateFuturesWithExtendedMarketDailyAlgorithm : BasicTemplateFuturesDailyAlgorithm
-    {
-        protected override bool ExtendedMarketHours => true;
-
-        /// <summary>
-        /// This is used by the regression test system to indicate which languages this algorithm is written in.
-        /// </summary>
-        public override List<Language> Languages { get; } = new() { Language.CSharp, Language.Python };
-
-        /// <summary>
-        /// Data Points count of all timeslices of algorithm
-        /// </summary>
-        public override long DataPoints => 14884;
-
-        /// <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 Orders", "32"},
-            {"Average Win", "0.33%"},
-            {"Average Loss", "-0.04%"},
-            {"Compounding Annual Return", "0.110%"},
-            {"Drawdown", "0.300%"},
-            {"Expectancy", "0.184"},
-            {"Start Equity", "1000000"},
-            {"End Equity", "1001108"},
-            {"Net Profit", "0.111%"},
-            {"Sharpe Ratio", "-1.688"},
-            {"Sortino Ratio", "-0.772"},
-            {"Probabilistic Sharpe Ratio", "14.944%"},
-            {"Loss Rate", "88%"},
-            {"Win Rate", "12%"},
-            {"Profit-Loss Ratio", "8.47"},
-            {"Alpha", "-0.007"},
-            {"Beta", "0.002"},
-            {"Annual Standard Deviation", "0.004"},
-            {"Annual Variance", "0"},
-            {"Information Ratio", "-1.353"},
-            {"Tracking Error", "0.089"},
-            {"Treynor Ratio", "-4.099"},
-            {"Total Fees", "$72.00"},
-            {"Estimated Strategy Capacity", "$0"},
-            {"Lowest Capacity Asset", "ES VRJST036ZY0X"},
-            {"Portfolio Turnover", "0.87%"},
-            {"OrderListHash", "ef59fd5e4a7ae483a60d25736cf5d2d8"}
-        };
-    }
-}

Algorithm.CSharp/BasicTemplateFuturesWithExtendedMarketHourlyAlgorithm.cs

@@ -1,80 +0,0 @@
-/*
- * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
- * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
-*/
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using QuantConnect.Data;
-using QuantConnect.Interfaces;
-using QuantConnect.Securities;
-
-namespace QuantConnect.Algorithm.CSharp
-{
-    /// <summary>
-    /// This regressions tests the BasicTemplateFuturesDailyAlgorithm with hour data and extended market hours
-    /// </summary>
-    /// <meta name="tag" content="using data" />
-    /// <meta name="tag" content="benchmarks" />
-    /// <meta name="tag" content="futures" />
-    public class BasicTemplateFuturesWithExtendedMarketHourlyAlgorithm : BasicTemplateFuturesHourlyAlgorithm
-    {
-        protected override bool ExtendedMarketHours => true;
-
-        /// <summary>
-        /// This is used by the regression test system to indicate which languages this algorithm is written in.
-        /// </summary>
-        public override List<Language> Languages { get; } = new() { Language.CSharp, Language.Python };
-
-        /// <summary>
-        /// Data Points count of all timeslices of algorithm
-        /// </summary>
-        public override long DataPoints => 228935;
-
-        /// <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 Orders", "1992"},
-            {"Average Win", "0.01%"},
-            {"Average Loss", "-0.01%"},
-            {"Compounding Annual Return", "-4.687%"},
-            {"Drawdown", "4.700%"},
-            {"Expectancy", "-0.911"},
-            {"Start Equity", "1000000"},
-            {"End Equity", "952789.22"},
-            {"Net Profit", "-4.721%"},
-            {"Sharpe Ratio", "-7.183"},
-            {"Sortino Ratio", "-5.14"},
-            {"Probabilistic Sharpe Ratio", "0%"},
-            {"Loss Rate", "97%"},
-            {"Win Rate", "3%"},
-            {"Profit-Loss Ratio", "2.04"},
-            {"Alpha", "-0.038"},
-            {"Beta", "-0.008"},
-            {"Annual Standard Deviation", "0.005"},
-            {"Annual Variance", "0"},
-            {"Information Ratio", "-1.702"},
-            {"Tracking Error", "0.09"},
-            {"Treynor Ratio", "5.054"},
-            {"Total Fees", "$4543.28"},
-            {"Estimated Strategy Capacity", "$3000.00"},
-            {"Lowest Capacity Asset", "ES VP274HSU1AF5"},
-            {"Portfolio Turnover", "56.73%"},
-            {"OrderListHash", "424536177e9be5895bab50638ef43a9d"}
-        };
-    }
-}

Algorithm.CSharp/BasicTemplateHourlyAlgorithm.cs

@@ -1,124 +0,0 @@
-/*
- * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
- * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
-*/
-
-using System.Collections.Generic;
-using QuantConnect.Data;
-using QuantConnect.Interfaces;
-
-namespace QuantConnect.Algorithm.CSharp
-{
-    /// <summary>
-    /// Basic template algorithm simply initializes the date range and cash. This is a skeleton
-    /// framework you can use for designing an algorithm.
-    /// </summary>
-    /// <meta name="tag" content="using data" />
-    /// <meta name="tag" content="using quantconnect" />
-    /// <meta name="tag" content="trading and orders" />
-    public class BasicTemplateHourlyAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
-    {
-        private Symbol _spy = QuantConnect.Symbol.Create("SPY", SecurityType.Equity, Market.USA);
-
-        /// <summary>
-        /// Initialise the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must initialized.
-        /// </summary>
-        public override void Initialize()
-        {
-            SetStartDate(2013, 10, 07);  //Set Start Date
-            SetEndDate(2013, 10, 11);    //Set End Date
-            SetCash(100000);             //Set Strategy Cash
-
-            // Find more symbols here: http://quantconnect.com/data
-            // Forex, CFD, Equities Resolutions: Tick, Second, Minute, Hour, Daily.
-            // Futures Resolution: Tick, Second, Minute
-            // Options Resolution: Minute Only.
-            AddEquity("SPY", Resolution.Hour);
-
-            // There are other assets with similar methods. See "Selecting Options" etc for more details.
-            // AddFuture, AddForex, AddCfd, AddOption
-        }
-
-        /// <summary>
-        /// OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here.
-        /// </summary>
-        /// <param name="slice">Slice object keyed by symbol containing the stock data</param>
-        public override void OnData(Slice slice)
-        {
-            if (!Portfolio.Invested)
-            {
-                SetHoldings(_spy, 1);
-                Debug("Purchased Stock");
-            }
-        }
-
-        /// <summary>
-        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
-        /// </summary>
-        public bool CanRunLocally { get; } = true;
-
-        /// <summary>
-        /// This is used by the regression test system to indicate which languages this algorithm is written in.
-        /// </summary>
-        public List<Language> Languages { get; } = new() { Language.CSharp };
-
-        /// <summary>
-        /// Data Points count of all timeslices of algorithm
-        /// </summary>
-        public long DataPoints => 78;
-
-        /// <summary>
-        /// Data Points count of the algorithm history
-        /// </summary>
-        public int AlgorithmHistoryDataPoints => 0;
-
-        /// <summary>
-        /// Final status of the algorithm
-        /// </summary>
-        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
-
-        /// <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 Orders", "1"},
-            {"Average Win", "0%"},
-            {"Average Loss", "0%"},
-            {"Compounding Annual Return", "227.693%"},
-            {"Drawdown", "2.000%"},
-            {"Expectancy", "0"},
-            {"Start Equity", "100000"},
-            {"End Equity", "101529.08"},
-            {"Net Profit", "1.529%"},
-            {"Sharpe Ratio", "8.855"},
-            {"Sortino Ratio", "0"},
-            {"Probabilistic Sharpe Ratio", "67.609%"},
-            {"Loss Rate", "0%"},
-            {"Win Rate", "0%"},
-            {"Profit-Loss Ratio", "0"},
-            {"Alpha", "-0.005"},
-            {"Beta", "0.996"},
-            {"Annual Standard Deviation", "0.222"},
-            {"Annual Variance", "0.049"},
-            {"Information Ratio", "-14.564"},
-            {"Tracking Error", "0.001"},
-            {"Treynor Ratio", "1.971"},
-            {"Total Fees", "$3.44"},
-            {"Estimated Strategy Capacity", "$110000000.00"},
-            {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
-            {"Portfolio Turnover", "19.96%"},
-            {"OrderListHash", "966f8355817adbc8c724d1062691a60b"}
-        };
-    }
-}

Algorithm.CSharp/BasicTemplateIndexAlgorithm.cs

@@ -1,176 +0,0 @@
-/*
- * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
- * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
-*/
-
-using System;
-using QuantConnect.Data;
-using System.Collections.Generic;
-using QuantConnect.Indicators;
-using QuantConnect.Interfaces;
-
-namespace QuantConnect.Algorithm.CSharp
-{
-    /// <summary>
-    /// This example demonstrates how to add index asset types.
-    /// </summary>
-    /// <meta name="tag" content="using data" />
-    /// <meta name="tag" content="benchmarks" />
-    /// <meta name="tag" content="indexes" />
-    public class BasicTemplateIndexAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
-    {
-        protected Symbol Spx { get; set; }
-        protected Symbol SpxOption { get; set; }
-        private ExponentialMovingAverage _emaSlow;
-        private ExponentialMovingAverage _emaFast;
-
-        protected virtual Resolution Resolution => Resolution.Minute;
-        protected virtual int StartDay => 4;
-
-        /// <summary>
-        /// Initialize your algorithm and add desired assets.
-        /// </summary>
-        public override void Initialize()
-        {
-            SetStartDate(2021, 1, StartDay);
-            SetEndDate(2021, 1, 18);
-            SetCash(1000000);
-
-            // Use indicator for signal; but it cannot be traded
-            Spx = AddIndex("SPX", Resolution).Symbol;
-
-            // Trade on SPX ITM calls
-            SpxOption = QuantConnect.Symbol.CreateOption(
-                Spx,
-                Market.USA,
-                OptionStyle.European,
-                OptionRight.Call,
-                3200m,
-                new DateTime(2021, 1, 15));
-
-            AddIndexOptionContract(SpxOption, Resolution);
-
-            _emaSlow = EMA(Spx, Resolution > Resolution.Minute ? 6 : 80);
-            _emaFast = EMA(Spx, Resolution > Resolution.Minute ? 2 : 200);
-
-            Settings.DailyPreciseEndTime = true;
-        }
-
-        /// <summary>
-        /// Index EMA Cross trading underlying.
-        /// </summary>
-        public override void OnData(Slice slice)
-        {
-            if (!slice.Bars.ContainsKey(Spx) || !slice.Bars.ContainsKey(SpxOption))
-            {
-                return;
-            }
-
-            // Warm up indicators
-            if (!_emaSlow.IsReady)
-            {
-                return;
-            }
-
-            if (_emaFast > _emaSlow)
-            {
-                SetHoldings(SpxOption, 1);
-            }
-            else
-            {
-                Liquidate();
-            }
-        }
-
-        /// <summary>
-        /// Asserts indicators are ready
-        /// </summary>
-        /// <exception cref="RegressionTestException"></exception>
-        protected void AssertIndicators()
-        {
-            if (!_emaSlow.IsReady || !_emaFast.IsReady)
-            {
-                throw new RegressionTestException("Indicators are not ready!");
-            }
-        }
-
-        public override void OnEndOfAlgorithm()
-        {
-            if (Portfolio[Spx].TotalSaleVolume > 0)
-            {
-                throw new RegressionTestException("Index is not tradable.");
-            }
-            AssertIndicators();
-        }
-
-        /// <summary>
-        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
-        /// </summary>
-        public virtual bool CanRunLocally { get; } = true;
-
-        /// <summary>
-        /// This is used by the regression test system to indicate which languages this algorithm is written in.
-        /// </summary>
-        public virtual List<Language> Languages { get; } = new() { Language.CSharp, Language.Python };
-
-        /// <summary>
-        /// Data Points count of all timeslices of algorithm
-        /// </summary>
-        public virtual long DataPoints => 16199;
-
-        /// <summary>
-        /// Data Points count of the algorithm history
-        /// </summary>
-        public virtual int AlgorithmHistoryDataPoints => 0;
-
-        /// <summary>
-        /// Final status of the algorithm
-        /// </summary>
-        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
-
-        /// <summary>
-        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
-        /// </summary>
-        public virtual Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
-        {
-            {"Total Orders", "3"},
-            {"Average Win", "7.08%"},
-            {"Average Loss", "0%"},
-            {"Compounding Annual Return", "603.355%"},
-            {"Drawdown", "3.400%"},
-            {"Expectancy", "0"},
-            {"Start Equity", "1000000"},
-            {"End Equity", "1064395"},
-            {"Net Profit", "6.440%"},
-            {"Sharpe Ratio", "-4.563"},
-            {"Sortino Ratio", "0"},
-            {"Probabilistic Sharpe Ratio", "0.781%"},
-            {"Loss Rate", "0%"},
-            {"Win Rate", "100%"},
-            {"Profit-Loss Ratio", "0"},
-            {"Alpha", "-0.169"},
-            {"Beta", "0.073"},
-            {"Annual Standard Deviation", "0.028"},
-            {"Annual Variance", "0.001"},
-            {"Information Ratio", "-6.684"},
-            {"Tracking Error", "0.099"},
-            {"Treynor Ratio", "-1.771"},
-            {"Total Fees", "$0.00"},
-            {"Estimated Strategy Capacity", "$3000.00"},
-            {"Lowest Capacity Asset", "SPX XL80P3GHDZXQ|SPX 31"},
-            {"Portfolio Turnover", "23.97%"},
-            {"OrderListHash", "51f1bc2ea080df79748dc66c2520b782"}
-        };
-    }
-}

Algorithm.CSharp/BasicTemplateIndexDailyAlgorithm.cs

@@ -1,155 +0,0 @@
-/*
- * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
- * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
-*/
-
-using System;
-using System.Linq;
-using QuantConnect.Data;
-using System.Collections.Generic;
-using QuantConnect.Data.Market;
-
-namespace QuantConnect.Algorithm.CSharp
-{
-    /// <summary>
-    /// Regression for running an Index algorithm with Daily data
-    /// </summary>
-    public class BasicTemplateIndexDailyAlgorithm : BasicTemplateIndexAlgorithm
-    {
-        protected override Resolution Resolution => Resolution.Daily;
-        protected override int StartDay => 1;
-
-        // two complete weeks starting from the 5th. The 18th bar is not included since it is a holiday
-        protected virtual int ExpectedBarCount => 2 * 5;
-        protected int BarCounter { get; set; }
-
-        /// <summary>
-        /// Purchase a contract when we are not invested, liquidate otherwise
-        /// </summary>
-        public override void OnData(Slice slice)
-        {
-            if (!Portfolio.Invested)
-            {
-                // SPX Index is not tradable, but we can trade an option
-                MarketOrder(SpxOption, 1);
-            }
-            else
-            {
-                Liquidate();
-            }
-
-            // Count how many slices we receive with SPX data in it to assert later
-            if (slice.ContainsKey(Spx))
-            {
-                BarCounter++;
-            }
-        }
-
-        public override void OnEndOfAlgorithm()
-        {
-            if (BarCounter != ExpectedBarCount)
-            {
-                throw new ArgumentException($"Bar Count {BarCounter} is not expected count of {ExpectedBarCount}");
-            }
-            AssertIndicators();
-
-            if (Resolution != Resolution.Daily)
-            {
-                return;
-            }
-
-            var openInterest = Securities[SpxOption].Cache.GetAll<OpenInterest>();
-            if (openInterest.Single().EndTime != new DateTime(2021, 1, 15, 23, 0, 0))
-            {
-                throw new ArgumentException($"Unexpected open interest time: {openInterest.Single().EndTime}");
-            }
-
-            foreach (var symbol in new[] { SpxOption, Spx })
-            {
-                var history = History(symbol, 10).ToList();
-                if (history.Count != 10)
-                {
-                    throw new RegressionTestException($"Unexpected history count: {history.Count}");
-                }
-                if (history.Any(x => x.Time.TimeOfDay != new TimeSpan(8, 30, 0)))
-                {
-                    throw new RegressionTestException($"Unexpected history data start time");
-                }
-                if (history.Any(x => x.EndTime.TimeOfDay != new TimeSpan(15, 15, 0)))
-                {
-                    throw new RegressionTestException($"Unexpected history data end time");
-                }
-            }
-        }
-
-        /// <summary>
-        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
-        /// </summary>
-        public override bool CanRunLocally { get; } = true;
-
-        /// <summary>
-        /// This is used by the regression test system to indicate which languages this algorithm is written in.
-        /// </summary>
-        public override List<Language> Languages { get; } = new() { Language.CSharp, Language.Python };
-
-        /// <summary>
-        /// Data Points count of all timeslices of algorithm
-        /// </summary>
-        public override long DataPoints => 121;
-
-        /// <summary>
-        /// Data Points count of the algorithm history
-        /// </summary>
-        public override int AlgorithmHistoryDataPoints => 30;
-
-        /// <summary>
-        /// Final status of the algorithm
-        /// </summary>
-        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
-
-        /// <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 Orders", "11"},
-            {"Average Win", "0%"},
-            {"Average Loss", "0%"},
-            {"Compounding Annual Return", "621.484%"},
-            {"Drawdown", "0%"},
-            {"Expectancy", "0"},
-            {"Start Equity", "1000000"},
-            {"End Equity", "1084600"},
-            {"Net Profit", "8.460%"},
-            {"Sharpe Ratio", "9.923"},
-            {"Sortino Ratio", "0"},
-            {"Probabilistic Sharpe Ratio", "93.682%"},
-            {"Loss Rate", "0%"},
-            {"Win Rate", "0%"},
-            {"Profit-Loss Ratio", "0"},
-            {"Alpha", "3.61"},
-            {"Beta", "-0.513"},
-            {"Annual Standard Deviation", "0.359"},
-            {"Annual Variance", "0.129"},
-            {"Information Ratio", "8.836"},
-            {"Tracking Error", "0.392"},
-            {"Treynor Ratio", "-6.937"},
-            {"Total Fees", "$0.00"},
-            {"Estimated Strategy Capacity", "$0"},
-            {"Lowest Capacity Asset", "SPX XL80P3GHDZXQ|SPX 31"},
-            {"Portfolio Turnover", "2.42%"},
-            {"OrderListHash", "61e8517ac3da6bed414ef23d26736fef"}
-        };
-    }
-}

Algorithm.CSharp/BasicTemplateIndexHourlyAlgorithm.cs

@@ -1,72 +0,0 @@
-using System.Collections.Generic;
-
-namespace QuantConnect.Algorithm.CSharp
-{
-    /// <summary>
-    /// Regression for running an Index algorithm with Hourly data
-    /// </summary>
-    public class BasicTemplateIndexHourlyAlgorithm : BasicTemplateIndexDailyAlgorithm
-    {
-        protected override Resolution Resolution => Resolution.Hour;
-        protected override int ExpectedBarCount => base.ExpectedBarCount * 8;
-
-        /// <summary>
-        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
-        /// </summary>
-        public override bool CanRunLocally { get; } = true;
-
-        /// <summary>
-        /// This is used by the regression test system to indicate which languages this algorithm is written in.
-        /// </summary>
-        public override List<Language> Languages { get; } = new() { Language.CSharp };
-
-        /// <summary>
-        /// Data Points count of all timeslices of algorithm
-        /// </summary>
-        public override long DataPoints => 401;
-
-        /// <summary>
-        /// Data Points count of the algorithm history
-        /// </summary>
-        public override int AlgorithmHistoryDataPoints => 0;
-
-        /// <summary>
-        /// Final status of the algorithm
-        /// </summary>
-        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
-
-        /// <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 Orders", "81"},
-            {"Average Win", "1.28%"},
-            {"Average Loss", "-0.06%"},
-            {"Compounding Annual Return", "-20.546%"},
-            {"Drawdown", "1.800%"},
-            {"Expectancy", "-0.402"},
-            {"Start Equity", "1000000"},
-            {"End Equity", "990775"},
-            {"Net Profit", "-0.922%"},
-            {"Sharpe Ratio", "-2.903"},
-            {"Sortino Ratio", "-6.081"},
-            {"Probabilistic Sharpe Ratio", "22.230%"},
-            {"Loss Rate", "97%"},
-            {"Win Rate", "3%"},
-            {"Profit-Loss Ratio", "19.95"},
-            {"Alpha", "-0.157"},
-            {"Beta", "0.025"},
-            {"Annual Standard Deviation", "0.053"},
-            {"Annual Variance", "0.003"},
-            {"Information Ratio", "-2.07"},
-            {"Tracking Error", "0.121"},
-            {"Treynor Ratio", "-6.189"},
-            {"Total Fees", "$0.00"},
-            {"Estimated Strategy Capacity", "$300000.00"},
-            {"Lowest Capacity Asset", "SPX XL80P3GHDZXQ|SPX 31"},
-            {"Portfolio Turnover", "24.63%"},
-            {"OrderListHash", "44325fc1fdebb8e54f64a3f6e8a4bcd7"}
-        };
-    }
-}

Algorithm.CSharp/BasicTemplateIndexOptionsAlgorithm.cs

@@ -1,211 +0,0 @@
-/*
- * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
- * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
-*/
-
-using QuantConnect.Data;
-using System.Collections.Generic;
-using QuantConnect.Indicators;
-using QuantConnect.Interfaces;
-
-namespace QuantConnect.Algorithm.CSharp
-{
-    /// <summary>
-    /// This example demonstrates how to add index asset types and trade index options on SPX.
-    /// </summary>
-    public class BasicTemplateIndexOptionsAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
-    {
-        private Symbol _spx;
-        private ExponentialMovingAverage _emaSlow;
-        private ExponentialMovingAverage _emaFast;
-        protected virtual Resolution Resolution => Resolution.Minute;
-        protected virtual int StartDay => 4;
-
-        /// <summary>
-        /// Initialize your algorithm and add desired assets.
-        /// </summary>
-        public override void Initialize()
-        {
-            SetStartDate(2021, 1, StartDay);
-            SetEndDate(2021, 2, 1);
-            SetCash(1000000);
-
-            // Use indicator for signal; but it cannot be traded.
-            // We will instead trade on SPX options
-            _spx = AddIndex("SPX", Resolution).Symbol;
-            var spxOptions = AddIndexOption(_spx, Resolution);
-            spxOptions.SetFilter(filterFunc => filterFunc.CallsOnly());
-
-            _emaSlow = EMA(_spx, Resolution > Resolution.Minute ? 6 : 80);
-            _emaFast = EMA(_spx, Resolution > Resolution.Minute ? 2 : 200);
-
-            Settings.DailyPreciseEndTime = true;
-        }
-
-        /// <summary>
-        /// Index EMA Cross trading index options of the index.
-        /// </summary>
-        public override void OnData(Slice slice)
-        {
-            if (!slice.Bars.ContainsKey(_spx))
-            {
-                Debug($"No SPX on {Time}");
-                return;
-            }
-
-            // Warm up indicators
-            if (!_emaSlow.IsReady)
-            {
-                Debug($"EMA slow not ready on {Time}");
-                return;
-            }
-
-            foreach (var chain in slice.OptionChains.Values)
-            {
-                foreach (var contract in chain.Contracts.Values)
-                {
-                    if (contract.Expiry.Month == 3 && contract.Symbol.ID.StrikePrice == 3700m && contract.Right == OptionRight.Call && slice.QuoteBars.ContainsKey(contract.Symbol))
-                    {
-                        Log($"{Time} {contract.Strike}{(contract.Right == OptionRight.Call ? 'C' : 'P')} -- {slice.QuoteBars[contract.Symbol]}");
-                    }
-
-                    if (Portfolio.Invested)
-                    {
-                        continue;
-                    }
-
-                    if (_emaFast > _emaSlow && contract.Right == OptionRight.Call)
-                    {
-                        Liquidate(InvertOption(contract.Symbol));
-                        MarketOrder(contract.Symbol, 1);
-                    }
-                    else if (_emaFast < _emaSlow && contract.Right == OptionRight.Put)
-                    {
-                        Liquidate(InvertOption(contract.Symbol));
-                        MarketOrder(contract.Symbol, 1);
-                    }
-                }
-            }
-        }
-
-        public override void OnEndOfAlgorithm()
-        {
-            if (Portfolio[_spx].TotalSaleVolume > 0)
-            {
-                throw new RegressionTestException("Index is not tradable.");
-            }
-            if (Portfolio.TotalSaleVolume == 0)
-            {
-                throw new RegressionTestException("Trade volume should be greater than zero by the end of this algorithm");
-            }
-            AssertIndicators();
-        }
-
-        public Symbol InvertOption(Symbol symbol)
-        {
-            return QuantConnect.Symbol.CreateOption(
-                symbol.Underlying,
-                symbol.ID.Market,
-                symbol.ID.OptionStyle,
-                symbol.ID.OptionRight == OptionRight.Call ? OptionRight.Put : OptionRight.Call,
-                symbol.ID.StrikePrice,
-                symbol.ID.Date);
-        }
-
-        /// <summary>
-        /// Asserts indicators are ready
-        /// </summary>
-        /// <exception cref="RegressionTestException"></exception>
-        protected void AssertIndicators()
-        {
-            if (!_emaSlow.IsReady || !_emaFast.IsReady)
-            {
-                throw new RegressionTestException("Indicators are not ready!");
-            }
-        }
-
-        /// <summary>
-        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
-        /// </summary>
-        public virtual bool CanRunLocally { get; } = false;
-
-        /// <summary>
-        /// This is used by the regression test system to indicate which languages this algorithm is written in.
-        /// </summary>
-        public virtual List<Language> Languages { get; } = new() { Language.CSharp, Language.Python };
-
-        /// <summary>
-        /// Data Points count of all timeslices of algorithm
-        /// </summary>
-        public virtual long DataPoints => 0;
-
-        /// </summary>
-        /// Data Points count of the algorithm history
-        /// </summary>
-        public virtual int AlgorithmHistoryDataPoints => 0;
-
-        /// <summary>
-        /// Final status of the algorithm
-        /// </summary>
-        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
-
-        /// <summary>
-        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
-        /// </summary>
-        public virtual Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
-        {
-            {"Total Orders", "8220"},
-            {"Average Win", "0.00%"},
-            {"Average Loss", "0.00%"},
-            {"Compounding Annual Return", "-100.000%"},
-            {"Drawdown", "13.500%"},
-            {"Expectancy", "-0.818"},
-            {"Net Profit", "-13.517%"},
-            {"Sharpe Ratio", "-2.678"},
-            {"Probabilistic Sharpe Ratio", "0%"},
-            {"Loss Rate", "89%"},
-            {"Win Rate", "11%"},
-            {"Profit-Loss Ratio", "0.69"},
-            {"Alpha", "4.398"},
-            {"Beta", "-0.989"},
-            {"Annual Standard Deviation", "0.373"},
-            {"Annual Variance", "0.139"},
-            {"Information Ratio", "-12.816"},
-            {"Tracking Error", "0.504"},
-            {"Treynor Ratio", "1.011"},
-            {"Total Fees", "$15207.00"},
-            {"Estimated Strategy Capacity", "$8800000.00"},
-            {"Fitness Score", "0.033"},
-            {"Kelly Criterion Estimate", "0"},
-            {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "-8.62"},
-            {"Return Over Maximum Drawdown", "-7.81"},
-            {"Portfolio Turnover", "302.321"},
-            {"Total Insights Generated", "0"},
-            {"Total Insights Closed", "0"},
-            {"Total Insights Analysis Completed", "0"},
-            {"Long Insight Count", "0"},
-            {"Short Insight Count", "0"},
-            {"Long/Short Ratio", "100%"},
-            {"Estimated Monthly Alpha Value", "$0"},
-            {"Total Accumulated Estimated Alpha Value", "$0"},
-            {"Mean Population Estimated Insight Value", "$0"},
-            {"Mean Population Direction", "0%"},
-            {"Mean Population Magnitude", "0%"},
-            {"Rolling Averaged Population Direction", "0%"},
-            {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "35b3f4b7a225468d42ca085386a2383e"}
-        };
-    }
-}

Algorithm.CSharp/BasicTemplateIndexOptionsDailyAlgorithm.cs

@@ -1,116 +0,0 @@
-/*
- * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
- * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
-*/
-
-using System.Linq;
-using QuantConnect.Data;
-using System.Collections.Generic;
-
-namespace QuantConnect.Algorithm.CSharp
-{
-    /// <summary>
-    /// Regression for running an IndexOptions algorithm with Daily data
-    /// </summary>
-    public class BasicTemplateIndexOptionsDailyAlgorithm : BasicTemplateIndexOptionsAlgorithm
-    {
-        protected override Resolution Resolution => Resolution.Daily;
-        protected override int StartDay => 1;
-        
-        /// <summary>
-        /// Index EMA Cross trading index options of the index.
-        /// </summary>
-        public override void OnData(Slice slice)
-        {
-            foreach (var chain in slice.OptionChains.Values)
-            {
-                // Select the contract with the lowest AskPrice
-                var contract = chain.Contracts.OrderBy(x => x.Value.AskPrice).FirstOrDefault().Value;
-
-                if (contract == null)
-                {
-                    return;
-                }
-                
-                if (Portfolio.Invested)
-                {
-                    Liquidate();
-                }
-                else
-                {
-                    MarketOrder(contract.Symbol, 1);
-                }
-            }
-        }
-
-        /// <summary>
-        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
-        /// </summary>
-        public override bool CanRunLocally { get; } = true;
-
-        /// <summary>
-        /// This is used by the regression test system to indicate which languages this algorithm is written in.
-        /// </summary>
-        public override List<Language> Languages { get; } = new() { Language.CSharp };
-
-        /// <summary>
-        /// Data Points count of all timeslices of algorithm
-        /// </summary>
-        public override long DataPoints => 356;
-
-        /// <summary>
-        /// Data Points count of the algorithm history
-        /// </summary>
-        public override int AlgorithmHistoryDataPoints => 0;
-
-        /// <summary>
-        /// Final status of the algorithm
-        /// </summary>
-        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
-
-        /// <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 Orders", "11"},
-            {"Average Win", "0%"},
-            {"Average Loss", "-0.01%"},
-            {"Compounding Annual Return", "-0.092%"},
-            {"Drawdown", "0.000%"},
-            {"Expectancy", "-1"},
-            {"Start Equity", "1000000"},
-            {"End Equity", "999920"},
-            {"Net Profit", "-0.008%"},
-            {"Sharpe Ratio", "-19.865"},
-            {"Sortino Ratio", "-175397.15"},
-            {"Probabilistic Sharpe Ratio", "0.013%"},
-            {"Loss Rate", "100%"},
-            {"Win Rate", "0%"},
-            {"Profit-Loss Ratio", "0"},
-            {"Alpha", "-0.003"},
-            {"Beta", "0"},
-            {"Annual Standard Deviation", "0"},
-            {"Annual Variance", "0"},
-            {"Information Ratio", "-0.454"},
-            {"Tracking Error", "0.138"},
-            {"Treynor Ratio", "-44.954"},
-            {"Total Fees", "$0.00"},
-            {"Estimated Strategy Capacity", "$0"},
-            {"Lowest Capacity Asset", "SPX XL80P59H5E6M|SPX 31"},
-            {"Portfolio Turnover", "0.00%"},
-            {"OrderListHash", "285cec32c0947f0e8cf90ccb672cfa43"}
-        };
-    }
-}

Algorithm.CSharp/BasicTemplateIndexOptionsHourlyAlgorithm.cs

@@ -1,87 +0,0 @@
-/*
- * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
- * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
-*/
-
-using System.Collections.Generic;
-
-namespace QuantConnect.Algorithm.CSharp
-{
-    /// <summary>
-    /// Regression for running an IndexOptions algorithm with Hourly data
-    /// </summary>
-    public class BasicTemplateIndexOptionsHourlyAlgorithm : BasicTemplateIndexOptionsDailyAlgorithm
-    {
-        protected override Resolution Resolution => Resolution.Hour;
-
-        /// <summary>
-        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
-        /// </summary>
-        public override bool CanRunLocally { get; } = true;
-
-        /// <summary>
-        /// This is used by the regression test system to indicate which languages this algorithm is written in.
-        /// </summary>
-        public override List<Language> Languages { get; } = new() { Language.CSharp };
-
-        /// <summary>
-        /// Data Points count of all timeslices of algorithm
-        /// </summary>
-        public override long DataPoints => 1269;
-
-        /// <summary>
-        /// Data Points count of the algorithm history
-        /// </summary>
-        public override int AlgorithmHistoryDataPoints => 0;
-
-        /// <summary>
-        /// Final status of the algorithm
-        /// </summary>
-        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
-
-        /// <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 Orders", "81"},
-            {"Average Win", "0.00%"},
-            {"Average Loss", "0.00%"},
-            {"Compounding Annual Return", "-0.006%"},
-            {"Drawdown", "0.000%"},
-            {"Expectancy", "-0.486"},
-            {"Start Equity", "1000000"},
-            {"End Equity", "999995"},
-            {"Net Profit", "0.000%"},
-            {"Sharpe Ratio", "-101.77"},
-            {"Sortino Ratio", "-9053542.758"},
-            {"Probabilistic Sharpe Ratio", "17.439%"},
-            {"Loss Rate", "97%"},
-            {"Win Rate", "3%"},
-            {"Profit-Loss Ratio", "17.50"},
-            {"Alpha", "-0.003"},
-            {"Beta", "-0"},
-            {"Annual Standard Deviation", "0"},
-            {"Annual Variance", "0"},
-            {"Information Ratio", "-0.449"},
-            {"Tracking Error", "0.138"},
-            {"Treynor Ratio", "116.921"},
-            {"Total Fees", "$0.00"},
-            {"Estimated Strategy Capacity", "$0"},
-            {"Lowest Capacity Asset", "SPX XL80P59H5E6M|SPX 31"},
-            {"Portfolio Turnover", "0.00%"},
-            {"OrderListHash", "75e6584cb26058b09720c3a828b9fbda"}
-        };
-    }
-}

Algorithm.CSharp/BasicTemplateIndiaAlgorithm.cs

@@ -1,134 +0,0 @@
-/*
- * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
- * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
-*/
-
-using QuantConnect.Data;
-using System.Collections.Generic;
-using QuantConnect.Interfaces;
-using QuantConnect.Orders;
-
-namespace QuantConnect.Algorithm.CSharp
-{
-    /// <summary>
-    /// Basic template India algorithm simply initializes the date range and cash. This is a skeleton
-    /// framework you can use for designing an algorithm.
-    /// </summary>
-    /// <meta name="tag" content="using data" />
-    /// <meta name="tag" content="using quantconnect" />
-    /// <meta name="tag" content="trading and orders" />
-    public class BasicTemplateIndiaAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
-    {
-        /// <summary>
-        /// Initialise the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must initialized.
-        /// </summary>
-        public override void Initialize()
-        {
-            SetAccountCurrency("INR");  //Set Account Currency
-            SetStartDate(2019, 1, 23);  //Set Start Date
-            SetEndDate(2019, 10, 31);   //Set End Date
-            SetCash(100000);            //Set Strategy Cash
-
-            // Find more symbols here: http://quantconnect.com/data
-            // Equities Resolutions: Tick, Second, Minute, Hour, Daily.
-            AddEquity("YESBANK", Resolution.Minute, Market.India);
-
-            //Set Order Properties as per the requirements for order placement
-            DefaultOrderProperties = new IndiaOrderProperties(exchange: Exchange.NSE);
-            //override default productType value set in config.json if needed - order specific productType value
-            //DefaultOrderProperties = new IndiaOrderProperties(exchange: Exchange.NSE, IndiaOrderProperties.IndiaProductType.CNC);
-
-            // General Debug statement for acknowledgement
-            Debug("Initialization Done");
-        }
-
-        /// <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 slice)
-        {
-            if (!Portfolio.Invested)
-            {
-                var marketTicket = MarketOrder("YESBANK", 1);
-            }
-        }
-
-        public override void OnOrderEvent(OrderEvent orderEvent)
-        {
-            if (orderEvent.Status.IsFill())
-            {
-                Debug($"Purchased Complete: {orderEvent.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 List<Language> Languages { get; } = new() { Language.CSharp, Language.Python };
-
-        /// <summary>
-        /// Data Points count of all timeslices of algorithm
-        /// </summary>
-        public long DataPoints => 29524;
-
-        /// <summary>
-        /// Data Points count of the algorithm history
-        /// </summary>
-        public int AlgorithmHistoryDataPoints => 0;
-
-        /// <summary>
-        /// Final status of the algorithm
-        /// </summary>
-        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
-
-        /// <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 Orders", "1"},
-            {"Average Win", "0%"},
-            {"Average Loss", "0%"},
-            {"Compounding Annual Return", "-0.010%"},
-            {"Drawdown", "0.000%"},
-            {"Expectancy", "0"},
-            {"Start Equity", "100000"},
-            {"End Equity", "99992.45"},
-            {"Net Profit", "-0.008%"},
-            {"Sharpe Ratio", "-497.389"},
-            {"Sortino Ratio", "-73.22"},
-            {"Probabilistic Sharpe Ratio", "0.001%"},
-            {"Loss Rate", "0%"},
-            {"Win Rate", "0%"},
-            {"Profit-Loss Ratio", "0"},
-            {"Alpha", "0"},
-            {"Beta", "0"},
-            {"Annual Standard Deviation", "0"},
-            {"Annual Variance", "0"},
-            {"Information Ratio", "-1.183"},
-            {"Tracking Error", "0"},
-            {"Treynor Ratio", "0"},
-            {"Total Fees", "₹6.00"},
-            {"Estimated Strategy Capacity", "₹61000000000.00"},
-            {"Lowest Capacity Asset", "YESBANK UL"},
-            {"Portfolio Turnover", "0.00%"},
-            {"OrderListHash", "7a0257f08e3bb9143b825e07ab47fea0"}
-        };
-    }
-}

Algorithm.CSharp/BasicTemplateIndiaIndexAlgorithm.cs

@@ -1,158 +0,0 @@
-/*
- * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
- * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
-*/
-
-using System;
-using QuantConnect.Data;
-using System.Collections.Generic;
-using QuantConnect.Indicators;
-using QuantConnect.Interfaces;
-using QuantConnect.Orders;
-
-namespace QuantConnect.Algorithm.CSharp
-{
-    /// <summary>
-    /// This example demonstrates how to add index asset types.
-    /// </summary>
-    /// <meta name="tag" content="using data" />
-    /// <meta name="tag" content="benchmarks" />
-    /// <meta name="tag" content="indexes" />
-    public class BasicTemplateIndiaIndexAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
-    {
-        protected Symbol Nifty { get; set; }
-        protected Symbol NiftyETF { get; set; }
-        private ExponentialMovingAverage _emaSlow;
-        private ExponentialMovingAverage _emaFast;
-
-        /// <summary>
-        /// Initialize your algorithm and add desired assets.
-        /// </summary>
-        public override void Initialize()
-        {
-            SetAccountCurrency("INR"); //Set Account Currency
-            SetStartDate(2019, 1, 1);  //Set End Date
-            SetEndDate(2019, 1, 5);    //Set End Date
-            SetCash(1000000);          //Set Strategy Cash
-
-            // Use indicator for signal; but it cannot be traded
-            Nifty = AddIndex("NIFTY50", Resolution.Minute, Market.India).Symbol;
-
-            //Trade Index based ETF
-            NiftyETF = AddEquity("JUNIORBEES", Resolution.Minute, Market.India).Symbol;
-
-            //Set Order Properties as per the requirements for order placement
-            DefaultOrderProperties = new IndiaOrderProperties(exchange: Exchange.NSE);
-
-            _emaSlow = EMA(Nifty, 80);
-            _emaFast = EMA(Nifty, 200);
-        }
-
-        /// <summary>
-        /// Index EMA Cross trading underlying.
-        /// </summary>
-        public override void OnData(Slice slice)
-        {
-            if (!slice.Bars.ContainsKey(Nifty) || !slice.Bars.ContainsKey(NiftyETF))
-            {
-                return;
-            }
-
-            // Warm up indicators
-            if (!_emaSlow.IsReady)
-            {
-                return;
-            }
-
-            if (_emaFast > _emaSlow)
-            {
-                if (!Portfolio.Invested)
-                {
-                    var marketTicket = MarketOrder(NiftyETF, 1);
-                }
-            }
-            else
-            {
-                Liquidate();
-            }
-        }
-
-        public override void OnEndOfAlgorithm()
-        {
-            if (Portfolio[Nifty].TotalSaleVolume > 0)
-            {
-                throw new RegressionTestException("Index is not tradable.");
-            }
-        }
-
-        /// <summary>
-        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
-        /// </summary>
-        public virtual bool CanRunLocally { get; } = true;
-
-        /// <summary>
-        /// This is used by the regression test system to indicate which languages this algorithm is written in.
-        /// </summary>
-        public virtual List<Language> Languages { get; } = new() { Language.CSharp, Language.Python };
-
-        /// <summary>
-        /// Data Points count of all timeslices of algorithm
-        /// </summary>
-        public long DataPoints => 2882;
-
-        /// <summary>
-        /// Data Points count of the algorithm history
-        /// </summary>
-        public int AlgorithmHistoryDataPoints => 0;
-
-        /// <summary>
-        /// Final status of the algorithm
-        /// </summary>
-        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
-
-        /// <summary>
-        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
-        /// </summary>
-        public virtual Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
-        {
-            {"Total Orders", "6"},
-            {"Average Win", "0%"},
-            {"Average Loss", "0.00%"},
-            {"Compounding Annual Return", "-0.386%"},
-            {"Drawdown", "0.000%"},
-            {"Expectancy", "-1"},
-            {"Start Equity", "1000000"},
-            {"End Equity", "999961.17"},
-            {"Net Profit", "-0.004%"},
-            {"Sharpe Ratio", "-328.371"},
-            {"Sortino Ratio", "-328.371"},
-            {"Probabilistic Sharpe Ratio", "0%"},
-            {"Loss Rate", "100%"},
-            {"Win Rate", "0%"},
-            {"Profit-Loss Ratio", "0"},
-            {"Alpha", "0"},
-            {"Beta", "0"},
-            {"Annual Standard Deviation", "0"},
-            {"Annual Variance", "0"},
-            {"Information Ratio", "-23.595"},
-            {"Tracking Error", "0"},
-            {"Treynor Ratio", "0"},
-            {"Total Fees", "₹36.00"},
-            {"Estimated Strategy Capacity", "₹84000.00"},
-            {"Lowest Capacity Asset", "JUNIORBEES UL"},
-            {"Portfolio Turnover", "0.04%"},
-            {"OrderListHash", "79ab9ec506959c562be8b3cdbb174c39"}
-        };
-    }
-}

Algorithm.CSharp/BasicTemplateIntrinioEconomicData.cs

@@ -31,9 +31,9 @@ namespace QuantConnect.Algorithm.CSharp
     /// <meta name="tag" content="trading and orders" />
     public class BasicTemplateIntrinioEconomicData : QCAlgorithm
     {
-        // Set your Intrinio user and password.
-        private string _user = string.Empty;
-        private string _password = string.Empty;
+        // Set your Intrinino user and password.
+        public string _user = "";
+        public string _password = "";
 
         private Symbol _uso; // United States Oil Fund LP
         private Symbol _bno; // United States Brent Oil Fund LP
@@ -41,7 +41,7 @@ namespace QuantConnect.Algorithm.CSharp
         private readonly Identity _brent = new Identity("Brent");
         private readonly Identity _wti = new Identity("WTI");
 
-        private CompositeIndicator _spread;
+        private CompositeIndicator<IndicatorDataPoint> _spread;
 
         private ExponentialMovingAverage _emaWti;
 
@@ -55,7 +55,7 @@ namespace QuantConnect.Algorithm.CSharp
             SetEndDate(year: 2013, month: 12, day: 31); //Set End Date
             SetCash(startingCash: 100000); //Set Strategy Cash
 
-            // Set your Intrinio user and password.
+            // Set your Intrinino user and password.
             IntrinioConfig.SetUserAndPassword(_user, _password);
 
             // Set Intrinio config to make 1 call each minute, default is 1 call each 5 seconds.
@@ -81,9 +81,9 @@ namespace QuantConnect.Algorithm.CSharp
         ///     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 slice)
+        public override void OnData(Slice data)
         {
-            var customData = slice.Get<IntrinioEconomicData>();
+            var customData = data.Get<IntrinioEconomicData>();
             if (customData.Count == 0) return;
 
             foreach (var economicData in customData.Values)
@@ -116,7 +116,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
-            {"Total Orders", "91"},
+            {"Total Trades", "91"},
             {"Average Win", "0.09%"},
             {"Average Loss", "-0.01%"},
             {"Compounding Annual Return", "5.732%"},

Algorithm.CSharp/BasicTemplateMultiAssetAlgorithm.cs

@@ -56,12 +56,9 @@ namespace QuantConnect.Algorithm.CSharp
             // setting up S&P 500 EMini futures
             var futureSP500 = AddFuture(Futures.Indices.SP500EMini);
             _futureSymbol = futureSP500.Symbol;
-
+            
             // set our expiry filter for this futures chain
-            // SetFilter method accepts TimeSpan objects or integer for days.
-            // The following statements yield the same filtering criteria
-            futureSP500.SetFilter(10, 182);
-            // futureSP500.SetFilter(TimeSpan.FromDays(10), TimeSpan.FromDays(182));
+            futureSP500.SetFilter(TimeSpan.FromDays(10), TimeSpan.FromDays(182));
 
             // setting up Dow Jones ETF Options
             var option = AddOption("DIA");
@@ -69,11 +66,8 @@ namespace QuantConnect.Algorithm.CSharp
 
             option.PriceModel = OptionPriceModels.BinomialCoxRossRubinstein();
             // option.EnableGreekApproximation = true;
-            // set our strike/expiry filter for this option chain
-            // SetFilter method accepts TimeSpan objects or integer for days.
-            // The following statements yield the same filtering criteria
-            option.SetFilter(-2, +2, 0, 180);
-            // option.SetFilter(-2, +2, TimeSpan.Zero, TimeSpan.FromDays(180));
+            // set our expiry filter for this option chain
+            option.SetFilter(-2, +2, TimeSpan.Zero, TimeSpan.FromDays(180));
 
             // specifying zero benchmark
             SetBenchmark(date => 0m);
@@ -137,26 +131,26 @@ namespace QuantConnect.Algorithm.CSharp
 
             if (_barCount % 20 == 1)
             {
-                Log($"P/L:{Portfolio.TotalUnrealisedProfit.ToStringInvariant("0.00")}, " +
-                    $"Fees:{Portfolio.TotalFees.ToStringInvariant("0.00")}, " +
-                    $"Profit:{Portfolio.TotalProfit.ToStringInvariant("0.00")}, " +
-                    $"Eq:{Portfolio.TotalPortfolioValue.ToStringInvariant("0.00")}, " +
-                    $"Holdings:{Portfolio.TotalHoldingsValue.ToStringInvariant("0.00")}, " +
-                    $"Vol: {Portfolio.TotalSaleVolume.ToStringInvariant("0.00")}, " +
-                    $"Margin: {Portfolio.TotalMarginUsed.ToStringInvariant("0.00")}"
-                );
+                Log(String.Format("P/L:{0:0.00}, Fees:{1:0.00}, Profit:{2:0.00}, Eq:{3:0.00}, Holdings:{4:0.00}, Vol: {5:0.00}, Margin: {6:0.00}",
+                    Portfolio.TotalUnrealisedProfit,
+                    Portfolio.TotalFees,
+                    Portfolio.TotalProfit,
+                    Portfolio.TotalPortfolioValue,
+                    Portfolio.TotalHoldingsValue,
+                    Portfolio.TotalSaleVolume,
+                    Portfolio.TotalMarginUsed));
 
                 foreach (var holding in Securities.Values.OrderByDescending(x => x.Holdings.AbsoluteQuantity))
                 {
-                    Log($" - {holding.Symbol.Value}, " +
-                        $"Avg Prc:{holding.Holdings.AveragePrice.ToStringInvariant("0.00")}, " +
-                        $"Qty:{holding.Holdings.Quantity.ToStringInvariant("0.00")}, " +
-                        $"Mkt Prc:{holding.Holdings.Price.ToStringInvariant("0.00")}, " +
-                        $"Mkt Val:{holding.Holdings.HoldingsValue.ToStringInvariant("0.00")}, " +
-                        $"Unreal P/L: {holding.Holdings.UnrealizedProfit.ToStringInvariant("0.00")}, " +
-                        $"Fees: {holding.Holdings.TotalFees.ToStringInvariant("0.00")}, " +
-                        $"Vol: {holding.Holdings.TotalSaleVolume.ToStringInvariant("0.00")}"
-                    );
+                    Log(String.Format(" - {0}, Avg Prc:{1:0.00}, Qty:{2:0.00}, Mkt Prc:{3:0.00}, Mkt Val:{4:0.00}, Unreal P/L: {5:0.00}, Fees: {6:0.00}, Vol: {7:0.00}",
+                        holding.Symbol.Value,
+                        holding.Holdings.AveragePrice,
+                        holding.Holdings.Quantity,
+                        holding.Holdings.Price,
+                        holding.Holdings.HoldingsValue,
+                        holding.Holdings.UnrealizedProfit,
+                        holding.Holdings.TotalFees,
+                        holding.Holdings.TotalSaleVolume));
                 }
             }
 
@@ -167,20 +161,21 @@ namespace QuantConnect.Algorithm.CSharp
                     var underlying = Securities[chain.Key.Underlying];
                     foreach (var contract in chain.Value)
                     {
-                        Log($"{Time.ToStringInvariant()} {contract.Symbol.Value}," +
-                            $"B={contract.BidPrice.ToStringInvariant()} " +
-                            $"A={contract.AskPrice.ToStringInvariant()} " +
-                            $"L={contract.LastPrice.ToStringInvariant()} " +
-                            $"OI={contract.OpenInterest.ToStringInvariant()} " +
-                            $"σ={underlying.VolatilityModel.Volatility:0.00} " +
-                            $"NPV={contract.TheoreticalPrice.ToStringInvariant("0.00")} " +
-                            $"Δ={contract.Greeks.Delta.ToStringInvariant("0.00")} " +
-                            $"Γ={contract.Greeks.Gamma.ToStringInvariant("0.00")} " +
-                            $"ν={contract.Greeks.Vega.ToStringInvariant("0.00")} " +
-                            $"ρ={contract.Greeks.Rho.ToStringInvariant("0.00")} " +
-                            $"Θ={(contract.Greeks.Theta / 365.0m).ToStringInvariant("0.00")} " +
-                            $"IV={contract.ImpliedVolatility.ToStringInvariant("0.00")}"
-                        );
+                        Log(String.Format(@"{0} {1},B={2} A={3} L={4} OI={5} σ={6:0.00} NPV={7:0.00} Δ={8:0.00} Γ={9:0.00} ν={10:0.00} ρ={11:0.00} Θ={12:0.00} IV={13:0.00}",
+                             Time.ToString(),
+                             contract.Symbol.Value,
+                             contract.BidPrice,
+                             contract.AskPrice,
+                             contract.LastPrice,
+                             contract.OpenInterest,
+                             underlying.VolatilityModel.Volatility,
+                             contract.TheoreticalPrice,
+                             contract.Greeks.Delta,
+                             contract.Greeks.Gamma,
+                             contract.Greeks.Vega,
+                             contract.Greeks.Rho,
+                             contract.Greeks.Theta / 365.0m,
+                             contract.ImpliedVolatility));
                     }
                 }
 
@@ -188,12 +183,13 @@ namespace QuantConnect.Algorithm.CSharp
                 {
                     foreach (var contract in chain.Value)
                     {
-                        Log($"{contract.Symbol.Value}, {Time}, " +
-                            $"B={contract.BidPrice} " +
-                            $"A={contract.AskPrice} " +
-                            $"L={contract.LastPrice} " +
-                            $"OI={contract.OpenInterest}"
-                        );
+                        Log(String.Format("{0}, {1}, B={2} A={3} L={4} OI={5}",
+                                contract.Symbol.Value,
+                                Time,
+                                contract.BidPrice,
+                                contract.AskPrice,
+                                contract.LastPrice,
+                                contract.OpenInterest));
                     }
                 }
             }
@@ -205,14 +201,14 @@ namespace QuantConnect.Algorithm.CSharp
 
             foreach (var kpv in slice.Bars)
             {
-                Log($"---> Bar: {Time}, {kpv.Key.Value}, {kpv.Value.Close.ToStringInvariant("0.0000")}");
+                Log($"---> Bar: {Time}, {kpv.Key.Value}, {kpv.Value.Close:0.0000}");
             }
         }
 
         /// <summary>
         /// Order fill event handler. On an order fill update the resulting information is passed to this method.
         /// </summary>
-        /// <param name="orderEvent">Order event details containing details of the events</param>
+        /// <param name="orderEvent">Order event details containing details of the evemts</param>
         /// <remarks>This method can be called asynchronously and so should only be used by seasoned C# experts. Ensure you use proper locks on thread-unsafe objects</remarks>
         public override void OnOrderEvent(OrderEvent orderEvent)
         {

Algorithm.CSharp/BasicTemplateOptionEquityStrategyAlgorithm.cs

@@ -1,151 +0,0 @@
-/*
- * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
- * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
-*/
-
-using System.Linq;
-using QuantConnect.Data;
-using QuantConnect.Orders;
-using QuantConnect.Interfaces;
-using QuantConnect.Data.Market;
-using System.Collections.Generic;
-using QuantConnect.Securities.Option;
-
-namespace QuantConnect.Algorithm.CSharp
-{
-    /// <summary>
-    /// Basic template algorithm trading a Call Butterfly option equity strategy
-    /// </summary>
-    /// <meta name="tag" content="options" />
-    /// <meta name="tag" content="using data" />
-    /// <meta name="tag" content="using quantconnect" />
-    /// <meta name="tag" content="trading and orders" />
-    public class BasicTemplateOptionEquityStrategyAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
-    {
-        private Symbol _optionSymbol;
-
-        public override void Initialize()
-        {
-            SetStartDate(2015, 12, 24);
-            SetEndDate(2015, 12, 24);
-
-            var equity = AddEquity("GOOG", leverage: 4);
-            var option = AddOption(equity.Symbol);
-            _optionSymbol = option.Symbol;
-
-            // set our strike/expiry filter for this option chain
-            option.SetFilter(u => u.Strikes(-2, +2)
-                // Expiration method accepts TimeSpan objects or integer for days.
-                // The following statements yield the same filtering criteria
-                .Expiration(0, 180));
-        }
-        /// <summary>
-        /// OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here.
-        /// </summary>
-        /// <param name="slice">Slice object keyed by symbol containing the stock data</param>
-        public override void OnData(Slice slice)
-        {
-            if (!Portfolio.Invested)
-            {
-                OptionChain chain;
-                if (IsMarketOpen(_optionSymbol) && slice.OptionChains.TryGetValue(_optionSymbol, out chain))
-                {
-                    var callContracts = chain.Where(contract => contract.Right == OptionRight.Call)
-                        .GroupBy(x => x.Expiry)
-                        .OrderBy(grouping => grouping.Key)
-                        .First()
-                        .OrderBy(x => x.Strike)
-                        .ToList();
-
-                    var expiry = callContracts[0].Expiry;
-                    var lowerStrike = callContracts[0].Strike;
-                    var middleStrike = callContracts[1].Strike;
-                    var higherStrike = callContracts[2].Strike;
-
-                    var optionStrategy = OptionStrategies.CallButterfly(_optionSymbol, higherStrike, middleStrike, lowerStrike, expiry);
-                    
-                    Order(optionStrategy, 10);
-                }
-            }
-        }
-
-        /// <summary>
-        /// Order fill event handler. On an order fill update the resulting information is passed to this method.
-        /// </summary>
-        /// <param name="orderEvent">Order event details containing details of the events</param>
-        /// <remarks>This method can be called asynchronously and so should only be used by seasoned C# experts. Ensure you use proper locks on thread-unsafe objects</remarks>
-        public override void OnOrderEvent(OrderEvent orderEvent)
-        {
-            Log($"{orderEvent}");
-        }
-
-        /// <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 => true;
-
-        /// <summary>
-        /// This is used by the regression test system to indicate which languages this algorithm is written in.
-        /// </summary>
-        public List<Language> Languages { get; } = new() { Language.CSharp, Language.Python };
-
-        /// <summary>
-        /// Data Points count of all timeslices of algorithm
-        /// </summary>
-        public long DataPoints => 15023;
-
-        /// <summary>
-        /// Data Points count of the algorithm history
-        /// </summary>
-        public int AlgorithmHistoryDataPoints => 0;
-
-        /// <summary>
-        /// Final status of the algorithm
-        /// </summary>
-        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
-
-        /// <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 Orders", "3"},
-            {"Average Win", "0%"},
-            {"Average Loss", "0%"},
-            {"Compounding Annual Return", "0%"},
-            {"Drawdown", "0%"},
-            {"Expectancy", "0"},
-            {"Start Equity", "100000"},
-            {"End Equity", "98024"},
-            {"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", "$26.00"},
-            {"Estimated Strategy Capacity", "$69000.00"},
-            {"Lowest Capacity Asset", "GOOCV W78ZERHAOVVQ|GOOCV VP83T1ZUHROL"},
-            {"Portfolio Turnover", "61.31%"},
-            {"OrderListHash", "35d406df401e5b27244e20f5ec57346e"}
-        };
-    }
-}