Inline some methods for performance (#4696)

- Add AggressiveInlining for some methods

.dockerignore

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

.gitignore

@@ -34,8 +34,9 @@
 
 # QC Cloud Setup Bash Files
 *.sh
-# Include docker build scripts for Mac/Linux
+# Include docker launch scripts for Mac/Linux
 !run_docker.sh
+!research/run_docker_notebook.sh
 
 # QC Config Files:
 # config.json
@@ -267,3 +268,6 @@ Launcher/Plugins/*
 /ApiPython/quantconnect.egg-info/*
 
 QuantConnect.Lean.sln.DotSettings*
+
+#User notebook files
+Research/Notebooks

.idea/Lean.iml

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

.idea/readme.md

@@ -0,0 +1,144 @@
+<h1>Local Development & Docker Integration with Pycharm</h1>
+
+This document contains information regarding ways to use Lean’s Docker image in conjunction with local development in Pycharm.
+
+
+<br />
+
+<h1>Getting Setup</h1>
+
+
+Before anything we need to ensure a few things have been done:
+
+
+1. Get [Pycharm Professional](https://www.jetbrains.com/pycharm/)**
+
+2. Get [Docker](https://docs.docker.com/get-docker/):
+    *   Follow the instructions for your Operating System
+    *   New to Docker? Try docker getting-started
+
+
+3. Pull Lean’s latest image from a terminal
+    *   _docker pull quantconnect/lean_
+
+4. Get Lean into Pycharm
+    *   Download the repo or clone it using: _git clone[ https://github.com/QuantConnect/Lean](https://github.com/QuantConnect/Lean)_
+    *   Open the folder using Pycharm
+
+
+_**PyCharm’s remote debugger requires PyCharm Professional._
+
+<br />
+
+<h1>Develop Algorithms Locally, Run in Container</h1>
+
+
+We have set up a relatively easy way to develop algorithms in your local IDE and push them into the container to be run and debugged. 
+
+Before we can use this method with Windows or Mac OS we need to share the Lean directory with Docker.
+
+<br />
+
+<h2>Activate File Sharing for Docker:</h2>
+
+*   Windows: 
+    *   [Guide to sharing](https://docs.docker.com/docker-for-windows/#file-sharing)
+    *   Share the LEAN root directory with docker
+  
+*   Mac:
+    *   [Guide to sharing](https://docs.docker.com/docker-for-mac/#file-sharing)
+    *   Share the LEAN root directory with docker
+
+*   Linux:
+    *    (No setup required)
+
+<br />
+
+<h2>Lean Configuration</h2>
+
+Next we need to be sure that our Lean configuration at **.\Launcher\config.json** is properly set. Just like running lean locally the config must reflect what we want Lean to run.
+
+You configuration file should look something like this:
+
+<h3>Python:</h3>
+
+    "algorithm-type-name": "**AlgorithmName**",
+
+    "algorithm-language": "Python",
+
+    "algorithm-location": "../../../Algorithm.Python/**AlgorithmName**.py",
+
+<h4>Note About Python Algorithm Location</h4>
+
+
+Our specific configuration binds the Algorithm.Python directory to the container by default so any algorithm you would like to run should be in that directory. Please ensure your algorithm location looks just the same as the example above. If you want to use a different location refer to the section bellow on setting that argument for the container and make sure your config.json also reflects this.
+
+
+<br />
+
+<h2>Running Lean in the Container</h2>
+
+This section will cover how to actually launch Lean in the container with your desired configuration.
+
+From a terminal; Pycharm has a built in terminal on the bottom taskbar labeled **Terminal**; launch the run_docker.bat/.sh script; there are a few choices on how to launch this:
+ 1. Launch with no parameters and answer the questions regarding configuration (Press enter for defaults)
+   
+        *   Enter docker image [default: quantconnect/lean:latest]:
+        *   Enter absolute path to Lean config file [default: _~currentDir_\Launcher\config.json]:
+        *   Enter absolute path to Data folder [default: ~_currentDir_\Data\]:
+        *   Enter absolute path to store results [default: ~_currentDir_\]:
+        *   Would you like to debug C#? (Requires mono debugger attachment) [default: N]:
+
+ 2. Using the **run_docker.cfg** to store args for repeated use; any blank entries will resort to default values! example: **_./run_docker.bat run_docker.cfg_**
+  
+        image=quantconnect/lean:latest
+        config_file=
+        data_dir=
+        results_dir=
+        debugging=
+        python_dir=
+
+ 3. Inline arguments; anything you don't enter will use the default args! example: **_./run_docker.bat debugging=y_** 
+      *    Accepted args for inline include all listed in the file in #2; must follow the **key=value** format
+
+<br />
+
+<h1>Debugging Python</h1>
+
+Debugging your Python algorithms requires an extra step within your configuration and inside of PyCharm. Thankfully we were able to configure the PyCharm launch configurations to take care of most of the work for you! 
+
+<br />
+
+<h2>Modifying the Configuration</h2>
+
+First in order to debug a Python algorithm in Pycharm we must make the following change to our configuration (Launcher\config.json) under the comment debugging configuration:
+
+    "debugging": true,
+    "debugging-method": "PyCharm",
+
+
+In setting this we are telling Lean to reach out and create a debugger connection using PyCharm’s PyDevd debugger server. Once this is set Lean will **always** attempt to connect to a debugger server on launch. **If you are no longer debugging set “debugging” to false.**
+
+<br />
+
+<h2>Using PyCharm Launch Options</h2>
+
+
+Now that Lean is configured for the debugger we can make use of the programmed launch options to connect. 
+
+
+
+**<h3>Container (Recommended)</h3>**
+
+
+To debug inside of the container we must first start the debugger server in Pycharm, to do this use the drop down configuration “Debug in Container” and launch the debugger. Be sure to set some breakpoints in your algorithms!
+
+Then we will need to launch the container, follow the steps described in the section “[Running Lean in the Container](#Running-Lean-in-the-Container)”. After launching the container the debugging configuration will take effect and it will connect to the debug server where you can begin debugging your algorithm.
+
+
+**<h3>Local</h3>**
+
+
+To debug locally we must run the program locally. First, just as the container setup, start the PyCharm debugger server by running the “Debug Local” configuration.
+
+Then start the program locally by whatever means you typically use, such as Mono, directly running the program at **QuantConnect.Lean.Launcher.exe**, etc. Once the program is running it will make the connection to your PyCharm debugger server where you can begin debugging your algorithm.

.idea/workspace.xml

@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="RunManager" selected="Python Debug Server.Debug in Container">
+    <configuration name="Debug Local" type="PyRemoteDebugConfigurationType" factoryName="Python Remote Debug">
+      <module name="LEAN" />
+      <option name="PORT" value="5678" />
+      <option name="HOST" value="localhost" />
+      <PathMappingSettings>
+        <option name="pathMappings">
+          <list />
+        </option>
+      </PathMappingSettings>
+      <option name="REDIRECT_OUTPUT" value="true" />
+      <option name="SUSPEND_AFTER_CONNECT" value="true" />
+      <method v="2" />
+    </configuration>
+    <configuration name="Debug in Container" type="PyRemoteDebugConfigurationType" factoryName="Python Remote Debug">
+      <module name="LEAN" />
+      <option name="PORT" value="5678" />
+      <option name="HOST" value="localhost" />
+      <PathMappingSettings>
+        <option name="pathMappings">
+          <list>
+            <mapping local-root="$PROJECT_DIR$" remote-root="/Lean" />
+          </list>
+        </option>
+      </PathMappingSettings>
+      <option name="REDIRECT_OUTPUT" value="true" />
+      <option name="SUSPEND_AFTER_CONNECT" value="true" />
+      <method v="2" />
+    </configuration>
+    <list>
+      <item itemvalue="Python Debug Server.Debug Local" />
+      <item itemvalue="Python Debug Server.Debug in Container" />
+    </list>
+  </component>
+</project>

.travis.yml

@@ -22,3 +22,5 @@ install:
 script:
   - msbuild /p:Configuration=Release /p:VbcToolExe=vbnc.exe QuantConnect.Lean.sln
   - mono ./testrunner/NUnit.ConsoleRunner.3.11.1/tools/nunit3-console.exe ./Tests/bin/Release/QuantConnect.Tests.dll --where "cat != TravisExclude" --labels=Off
+  - chmod +x ci_build_stubs.sh
+  - sudo -E ./ci_build_stubs.sh -ipy -g -p

.vs/readme.md

@@ -0,0 +1,136 @@
+<h1>Local Development & Docker Integration with Visual Studio</h1>
+
+
+This document contains information regarding ways to use Visual Studio to work with the Lean's Docker image.
+
+
+<br />
+
+<h1>Getting Setup</h1>
+
+
+Before anything we need to ensure a few things have been done:
+
+
+1. Get [Visual Studio](https://code.visualstudio.com/download)
+    *   Get the Extension [VSMonoDebugger](https://marketplace.visualstudio.com/items?itemName=GordianDotNet.VSMonoDebugger0d62) for C# Debugging
+
+2. Get [Docker](https://docs.docker.com/get-docker/):
+    *   Follow the instructions for your Operating System
+    *   New to Docker? Try docker getting-started
+
+
+3. Pull Lean’s latest image from a terminal
+    *   _docker pull quantconnect/lean_
+
+4. Get Lean into Visual Studio
+    *   Download the repo or clone it using: _git clone[ https://github.com/QuantConnect/Lean](https://github.com/QuantConnect/Lean)_
+    *   Open the solution **QuantConnect.Lean.sln** using Visual Studio
+
+
+<br />
+
+<h1>Develop Algorithms Locally, Run in Container</h1>
+
+
+We have set up a relatively easy way to develop algorithms in your local IDE and push them into the container to be run and debugged. 
+
+Before we can use this method with Windows or Mac OS we need to share the Lean directory with Docker.
+
+<br />
+
+<h2>Activate File Sharing for Docker:</h2>
+
+*   Windows: 
+    *   [Guide to sharing](https://docs.docker.com/docker-for-windows/#file-sharing)
+    *   Share the LEAN root directory with docker
+  
+*   Mac:
+    *   [Guide to sharing](https://docs.docker.com/docker-for-mac/#file-sharing)
+    *   Share the LEAN root directory with docker
+
+*   Linux:
+    *    (No setup required)
+
+<br />
+
+<h2>Lean Configuration</h2>
+
+Next we need to be sure that our Lean configuration at **.\Launcher\config.json** is properly set. Just like running lean locally the config must reflect what we want Lean to run.
+
+You 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>Important Note About C#</h2>
+
+In order to use a custom C# algorithm, the C# file must be compiled before running in the docker, as it is compiled into the file **"QuantConnect.Algorithm.CSharp.dll"**. Any new C# files will need to be added to the csproj compile list before it will compile, check **Algorithm.CSharp/QuantConnect.Algorithm.CSharp.csproj** for all algorithms that are compiled. Once there is an entry for your algorithm the project can be compiled by using  **Build > Build Solution**.
+
+If you would like to debug this file in the docker container one small change to the solutions target build is required.
+1. Right click on the solution **QuantConnect.Lean** in the _Solution Explorer_
+2. Select **Properties**
+3. For project entry **QuantConnect.Algorithm.CSharp** change the configuration to **DebugDocker**
+4. Select **Apply** and close out of the window.
+5. Build the project at least once before running the docker.
+
+<br />
+
+<h2>Running Lean in the Container</h2>
+
+This section will cover how to actually launch Lean in the container with your desired configuration.
+
+From a terminal launch the run_docker.bat/.sh script; there are a few choices on how to launch this:
+ 1. Launch with no parameters and answer the questions regarding configuration (Press enter for defaults)
+   
+        *   Enter docker image [default: quantconnect/lean:latest]:
+        *   Enter absolute path to Lean config file [default: _~currentDir_\Launcher\config.json]:
+        *   Enter absolute path to Data folder [default: ~_currentDir_\Data\]:
+        *   Enter absolute path to store results [default: ~_currentDir_\]:
+        *   Would you like to debug C#? (Requires mono debugger attachment) [default: N]:
+
+ 2. Using the **run_docker.cfg** to store args for repeated use; any blank entries will resort to default values! example: **_./run_docker.bat run_docker.cfg_**
+  
+        image=quantconnect/lean:latest
+        config_file=
+        data_dir=
+        results_dir=
+        debugging=
+        python_dir=
+
+ 3. Inline arguments; anything you don't enter will use the default args! example: **_./run_docker.bat debugging=y_** 
+      *    Accepted args for inline include all listed in the file in #2
+
+<br />
+
+<h1>Connecting to Mono Debugger</h1>
+
+If you launch the script with debugging set to **yes** (y), then you will need to connect to the debugging server with the mono extension that you installed in the setup stage.
+
+To setup the extension do the following:
+   * Go to **Extensions > Mono > Settings...**
+   * Enter the following for the settings:
+     * Remote Host IP: 127.0.0.1
+     * Remote Host Port: 55555
+     * Mono Debug Port: 55555
+   * Click **Save** and then close the extension settings
+  
+Now that the extension is setup use it to connect to the Docker container by using:
+*  **Extensions > Mono > Attach to mono debugger**
+
+The program should then launch and trigger any breakpoints you have set in your C# Algorithm.

.vscode/launch.json

@@ -0,0 +1,82 @@
+{
+    /*
+        VS Code Launch configurations for the LEAN engine
+
+        Launch w/ Mono (Local):
+        Builds the project with MSBuild and then launches the program using mono locally;
+        supports debugging. In order to use this you need msbuild and mono on your system path.
+        As well as the Mono Debug extension from the marketplace.
+        
+        Debug in Container:
+        Launches our run_docker script to start the container and attaches to the debugger.
+        Requires that you have built the project at least once as it will transfer the compiled
+        csharp files.
+        Requires Mono Debug extension from the marketplace.
+
+        Attach to Python (Container):
+        Will attempt to attach to LEAN in the container using PTVSD. Requires that the container is
+        actively running and config is set: "debugging": true, "debugging-method": "PTVSD",
+        Requires Python extension from the marketplace.
+
+        Attach to Python (Local):
+        Will attempt to attach to LEAN running locally using PTVSD. Requires that the process is
+        actively running and config is set: "debugging": true, "debugging-method": "PTVSD",
+        Requires Python extension from the marketplace.
+
+    */
+
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Launch w/ Mono (Local)",
+            "type": "mono",
+            "request": "launch",
+            "preLaunchTask": "build",
+            "cwd": "${workspaceFolder}/Launcher/bin/Debug/",
+            "program": "${workspaceFolder}/Launcher/bin/Debug/QuantConnect.Lean.Launcher.exe",
+            "args": [
+                "--data-folder",
+                "${workspaceFolder}/Data",
+                "--config",
+                "${workspaceFolder}/Launcher/config.json"],
+            "console": "externalTerminal"
+        },
+        {
+            "name": "Debug in Container",
+            "type": "mono",
+            "preLaunchTask": "run-docker",
+            "postDebugTask": "close-docker",
+            "request": "attach",
+            "address": "localhost",
+            "port": 55555
+        },
+        {
+            "name": "Attach to Mono",
+            "type": "mono",
+            "request": "attach",
+            "address": "localhost",
+            "postDebugTask": "close-docker",
+            "port": 55555
+        },
+        {
+            "name": "Attach to Python (Container)",
+            "type": "python",
+            "request": "attach",
+            "port": 5678,
+            "pathMappings":[{ 
+                "localRoot": "${workspaceFolder}", 
+                "remoteRoot": "/Lean/"
+            }]
+        },
+        {
+            "name": "Attach to Python (Local)",
+            "type": "python",
+            "request": "attach",
+            "port": 5678,
+            "pathMappings":[{ 
+                "localRoot": "${workspaceFolder}", 
+                "remoteRoot": "${workspaceFolder}"
+            }]
+        }
+    ]
+}

.vscode/readme.md

@@ -0,0 +1,197 @@
+<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 using Lean’s Docker image in conjunction with local development as well as running Lean locally.
+
+
+<br />
+
+<h1>Getting Setup</h1>
+
+
+Before anything we need to ensure a few things have been done:
+
+
+1. Get [Visual Studio Code](https://code.visualstudio.com/download)
+    *   Get the Extension [Mono Debug](https://marketplace.visualstudio.com/items?itemName=ms-vscode.mono-debug) for C# Debugging
+    *   Get the Extension [Python](https://marketplace.visualstudio.com/items?itemName=ms-python.python) for Python Debugging
+
+2. Get [Docker](https://docs.docker.com/get-docker/):
+    *   Follow the instructions for your Operating System
+    *   New to Docker? Try docker getting-started
+
+3. Install a compiler for the project **(Only needed for C# Debugging or Running Locally)**
+   *   On Linux or Mac: 
+       *   Install [mono-complete](https://www.mono-project.com/docs/getting-started/install/linux/)
+       *   Test msbuild with command: _msbuild -version_
+   *   On Windows: 
+       *   Visual Studio comes packed with msbuild or download without VS [here](https://visualstudio.microsoft.com/downloads/?q=build+tools)
+       *   Put msbuild on your system path and test with command: _msbuild -version_
+
+4. Pull Lean’s latest image from a terminal
+    *   _docker pull quantconnect/lean_
+
+5. 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
+
+
+<br />
+
+<h1>Develop Algorithms Locally, Run in Container</h1>
+
+
+We have set up a relatively easy way to develop algorithms in your local IDE and push them into the container to be run and debugged. 
+
+Before we can use this method with Windows or Mac OS we need to share the Lean directory with Docker.
+
+<br />
+
+<h2>Activate File Sharing for Docker:</h2>
+
+*   Windows: 
+    *   [Guide to sharing](https://docs.docker.com/docker-for-windows/#file-sharing)
+    *   Share the LEAN root directory with docker
+  
+*   Mac:
+    *   [Guide to sharing](https://docs.docker.com/docker-for-mac/#file-sharing)
+    *   Share the LEAN root directory with docker
+
+*   Linux:
+    *    (No setup required)
+
+<br />
+
+<h2>Lean Configuration</h2>
+
+Next we need to be sure that our Lean configuration at **.\Launcher\config.json** is properly set. Just like running lean locally the config must reflect what we want Lean to run.
+
+You 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",
+
+
+<h3>Important Note About C#</h3>
+
+In order to use a custom C# algorithm, the C# file must be compiled before running in the docker, as it is compiled into the file "QuantConnect.Algorithm.CSharp.dll". Any new C# files will need to be added to the csproj compile list before it will compile, check Algorithm.CSharp/QuantConnect.Algorithm.CSharp.csproj for all algorithms that are compiled. Once there is an entry for your algorithm the project can be compiled by using the “build” task under _“Terminal” > “Run Build Task”._ 
+
+Python **does not** have this requirement as the engine will compile it on the fly.
+
+<br />
+
+<h2>Running Lean in the Container</h2>
+
+This section will cover how to actually launch Lean in the container with your desired configuration.
+
+<br />
+
+<h3>Option 1 (Recommended)</h3>
+
+In VS Code click on the debug/run icon on the left toolbar, at the top you should see a drop down menu with launch options, be sure to select **Debug in Container**. This option will kick off a launch script that will start the docker. With this specific launch option the parameters are already configured in VS Codes **tasks.json** under the **run-docker** task args. These set arguements are:
+
+    "image=quantconnect/lean:latest",
+    "config_file=${workspaceFolder}/Launcher/config.json",
+    "data_dir=${workspaceFolder}/Data",
+    "results_dir=${workspaceFolder}/",
+    "debugging=Y",
+    "python_location=${workspaceFolder}/Algorithm.Python"
+
+As defaults these are all great! Feel free to change them as needed for your setup.
+
+<br />
+
+<h3>Option 2</h3>
+
+From a terminal launch the run_docker.bat/.sh script; there are a few choices on how to launch this:
+ 1. Launch with no parameters and answer the questions regarding configuration (Press enter for defaults)
+   
+        *   Enter docker image [default: quantconnect/lean:latest]:
+        *   Enter absolute path to Lean config file [default: _~currentDir_\Launcher\config.json]:
+        *   Enter absolute path to Data folder [default: ~_currentDir_\Data\]:
+        *   Enter absolute path to store results [default: ~_currentDir_\]:
+        *   Would you like to debug C#? (Requires mono debugger attachment) [default: N]:
+
+ 2. Using the **run_docker.cfg** to store args for repeated use; any blank entries will resort to default values! example: **_./run_docker.bat run_docker.cfg_**
+  
+        image=quantconnect/lean:latest
+        config_file=
+        data_dir=
+        results_dir=
+        debugging=
+        python_dir=
+
+ 3. Inline arguments; anything you don't enter will use the default args! example: **_./run_docker.bat debugging=y_** 
+      *    Accepted args for inline include all listed in the file in #2
+
+<br />
+
+<h1>Debugging Python</h1>
+
+Python algorithms require a little extra work in order to be able to debug them locally or in the container. Thankfully we were able to configure VS code tasks to take care of the work for you! Follow the steps below to get Python debugging working.
+
+<br />
+
+<h2>Modifying the Configuration</h2>
+
+First in order to debug a Python algorithm in VS Code we must make the following change to our configuration (Launcher\config.json) under the comment debugging configuration:
+
+    "debugging": true,
+    "debugging-method": "PTVSD",
+
+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 />
+
+<h2>Using VS Code Launch Options to Connect</h2>
+
+Now that Lean is configured for the python debugger we can make use of the programmed launch options to connect. 
+
+<br />
+
+<h3>Container</h3>
+
+
+To debug inside of the container we must first start the container, follow the steps described in the section “[Running Lean in the Container](#Running-Lean-in-the-Container)”. Once the container is started you should see the messages in Figure 2.
+
+If the message is displayed, use the same drop down for “Debug in Container” and select “Attach to Python (Container)”. Then press run, VS Code will now enter and debug any breakpoints you have set in your Python algorithm.
+
+<br />
+
+<h3>Local</h3>
+
+
+To debug locally we must run the program locally using the programmed task found under Terminal > Run Task > “Run Application”. Once Lean is started you should see the messages in Figure 2.
+
+If the message is displayed, use the launch option “Attach to Python (Local)”. 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!
+
+*   Error messages about build in VSCode points to comments in JSON. Either select **ignore** or follow steps described [here](https://stackoverflow.com/questions/47834825/in-vs-code-disable-error-comments-are-not-permitted-in-json) to remove the errors entirely.

.vscode/settings.json

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

.vscode/tasks.json

@@ -0,0 +1,111 @@
+{
+    /*
+        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": "msbuild",
+            "args": [
+                "/p:Configuration=Debug",
+                "/p:DebugType=portable",
+                "/t:build",
+            ],
+            "group": "build",
+            "presentation": {
+                "reveal": "silent"
+            },
+            "problemMatcher": "$msCompile"
+        },
+        {
+            "label": "force build linux",
+            "type": "shell",
+            "command": "msbuild",
+            "args": [
+                "/property:GenerateFullPaths=true",
+                "/p:Configuration=Debug",
+                "/p:DebugType=portable",
+                "/t:build",
+                "/p:ForceLinuxBuild=true"
+            ],
+            "group": "build",
+            "presentation": {
+                "reveal": "silent"
+            },
+            "problemMatcher": "$msCompile"
+        },
+        {
+            "label": "run-docker",
+            "type": "shell",
+            "isBackground": true,
+            "windows": {
+                "command": "${workspaceFolder}/run_docker.bat",
+            },
+            "linux": {
+                "command": "${workspaceFolder}/run_docker.sh"
+            },
+            "osx": {
+                "command": "${workspaceFolder}/run_docker.sh"
+            },
+            "args": [
+                "image=quantconnect/lean:latest",
+                "config_file=${workspaceFolder}/Launcher/config.json",
+                "data_dir=${workspaceFolder}/Data",
+                "results_dir=${workspaceFolder}/",
+                "debugging=Y",
+                "python_dir=${workspaceFolder}/Algorithm.Python",
+                "exit=Y"
+            ],
+            "problemMatcher": [
+                {
+                  "pattern": [
+                    {
+                      "regexp": ".",
+                      "file": 1,
+                      "location": 2,
+                      "message": 3
+                    }
+                  ],
+                  "background": {
+                    "activeOnStart": true,
+                    "beginsPattern": ".",
+                    "endsPattern": ".",
+                  }
+                }
+              ]
+        },
+        {
+            "label": "close-docker",
+            "type": "shell",
+            "command": "docker stop LeanEngine",
+            "presentation": {
+                "echo": false,
+                "reveal": "never",
+                "focus": false,
+                "panel": "shared",
+                "showReuseMessage": false,
+                "clear": true,
+            },
+            "linux":{
+                "command": "sudo docker stop LeanEngine"
+            }
+        },
+        {
+            "label": "Run Application",
+            "type": "process",
+            "command": "QuantConnect.Lean.Launcher.exe",
+            "args" : [
+                "--data-folder",
+                "${workspaceFolder}/Data",
+                "--config",
+                "${workspaceFolder}/Launcher/config.json"
+            ],
+            "options": {
+                "cwd": "${workspaceFolder}/Launcher/bin/Debug/"
+            }
+        }
+    ]
+}

Algorithm.CSharp/AltData/RobintrackHoldingsAlgorithm.cs

@@ -1,74 +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.Custom.Robintrack;
-
-namespace QuantConnect.Algorithm.CSharp.AltData
-{
-    /// <summary>
-    /// Looks at users holding the stock AAPL at a given point in time
-    /// and keeps track of changes in retail investor sentiment.
-    ///
-    /// We go long if the sentiment increases by 0.5%, and short if it decreases by -0.5%
-    /// </summary>
-    public class RobintrackHoldingsAlgorithm : QCAlgorithm
-    {
-        private Symbol _aapl;
-        private Symbol _aaplHoldings;
-        private decimal _lastValue;
-        private bool _isLong;
-
-        public override void Initialize()
-        {
-            SetStartDate(2018, 5, 1);
-            SetEndDate(2020, 5, 5);
-            SetCash(100000);
-
-            _aapl = AddEquity("AAPL", Resolution.Daily).Symbol;
-            _aaplHoldings = AddData<RobintrackHoldings>(_aapl).Symbol;
-            _isLong = false;
-        }
-
-        public override void OnData(Slice data)
-        {
-            foreach (var kvp in data.Get<RobintrackHoldings>())
-            {
-                var holdings = kvp.Value;
-
-                if (_lastValue != 0)
-                {
-                    var percentChange = (holdings.UsersHolding - _lastValue) / _lastValue;
-                    var holdingInfo = $"There are {holdings.UsersHolding} unique users holding {kvp.Key.Underlying} - users holding % of U.S. equities universe: {holdings.UniverseHoldingPercent * 100m}%";
-
-                    if (percentChange >= 0.005m && !_isLong)
-                    {
-                        Log($"{UtcTime} - Buying AAPL - {holdingInfo}");
-                        SetHoldings(_aapl, 0.5);
-                        _isLong = true;
-                    }
-                    else if (percentChange <= -0.005m && _isLong)
-                    {
-                        Log($"{UtcTime} - Shorting AAPL - {holdingInfo}");
-                        SetHoldings(_aapl, -0.5);
-                        _isLong = false;
-                    }
-                }
-
-                _lastValue = holdings.UsersHolding;
-            }
-        }
-    }
-}

Algorithm.CSharp/BasicTemplateOptionsFilterUniverseAlgorithm.cs

@@ -15,9 +15,11 @@
 */
 
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using QuantConnect.Data;
 using QuantConnect.Data.Market;
+using QuantConnect.Interfaces;
 using QuantConnect.Orders;
 using QuantConnect.Securities;
 
@@ -31,7 +33,7 @@ namespace QuantConnect.Algorithm.CSharp
     /// <meta name="tag" content="using data" />
     /// <meta name="tag" content="options" />
     /// <meta name="tag" content="filter selection" />
-    public class BasicTemplateOptionsFilterUniverseAlgorithm : QCAlgorithm
+    public class BasicTemplateOptionsFilterUniverseAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
     {
         private const string UnderlyingTicker = "GOOG";
         public Symbol OptionSymbol;
@@ -40,20 +42,17 @@ namespace QuantConnect.Algorithm.CSharp
         {
             SetStartDate(2015, 12, 24);
             SetEndDate(2015, 12, 24);
-            SetCash(10000);
+            SetCash(100000);
 
             var equity = AddEquity(UnderlyingTicker);
             var option = AddOption(UnderlyingTicker);
+            OptionSymbol = option.Symbol;
 
-            // set our custom filter for this option chain
-            option.SetFilter(universe => from symbol in universe
-                                                          .WeeklysOnly()
-                                                           // Expiration method accepts TimeSpan objects or integer for days.
-                                                           // The following statements yield the same filtering criteria
-                                                          .Expiration(0, 10)
-                                                          // .Expiration(TimeSpan.Zero, TimeSpan.FromDays(10))
+            // Set our custom universe filter, Expires today, is a call, and is within 10 dollars of the current price
+            option.SetFilter(universe => from symbol in universe.WeeklysOnly().Expiration(0, 1)
                                          where symbol.ID.OptionRight != OptionRight.Put &&
-                                              universe.Underlying.Price - symbol.ID.StrikePrice < 60
+                                              -10 < universe.Underlying.Price - symbol.ID.StrikePrice &&
+                                              universe.Underlying.Price - symbol.ID.StrikePrice < 10
                                          select symbol);
 
             // use the underlying equity as the benchmark
@@ -67,14 +66,13 @@ namespace QuantConnect.Algorithm.CSharp
                 OptionChain chain;
                 if (slice.OptionChains.TryGetValue(OptionSymbol, out chain))
                 {
-                    // find the second call strike under market price expiring today
+                    // Get the first ITM call expiring today
                     var contract = (
                         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
-                        ).Skip(2).FirstOrDefault();
+                        ).FirstOrDefault();
 
                     if (contract != null)
                     {
@@ -88,5 +86,62 @@ namespace QuantConnect.Algorithm.CSharp
         {
             Log(orderEvent.ToString());
         }
+
+        /// <summary>
+        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
+        /// </summary>
+        public bool CanRunLocally { get; } = true;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public Language[] Languages { get; } = { Language.CSharp, Language.Python };
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        {
+            {"Total Trades", "1"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "0%"},
+            {"Drawdown", "0%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "0%"},
+            {"Sharpe Ratio", "0"},
+            {"Probabilistic Sharpe Ratio", "0%"},
+            {"Loss Rate", "0%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "0"},
+            {"Beta", "0"},
+            {"Annual Standard Deviation", "0"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "0"},
+            {"Tracking Error", "0"},
+            {"Treynor Ratio", "0"},
+            {"Total Fees", "$1.00"},
+            {"Fitness Score", "0"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "0"},
+            {"Return Over Maximum Drawdown", "0"},
+            {"Portfolio Turnover", "0"},
+            {"Total Insights Generated", "0"},
+            {"Total Insights Closed", "0"},
+            {"Total Insights Analysis Completed", "0"},
+            {"Long Insight Count", "0"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "$0"},
+            {"Total Accumulated Estimated Alpha Value", "$0"},
+            {"Mean Population Estimated Insight Value", "$0"},
+            {"Mean Population Direction", "0%"},
+            {"Mean Population Magnitude", "0%"},
+            {"Rolling Averaged Population Direction", "0%"},
+            {"Rolling Averaged Population Magnitude", "0%"},
+            {"OrderListHash", "-1214175458"}
+        };
     }
 }

Algorithm.CSharp/CoarseTiingoNewsUniverseSelectionAlgorithm.cs

@@ -0,0 +1,119 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
+using System;
+using QuantConnect.Interfaces;
+using System.Collections.Generic;
+using System.Linq;
+using QuantConnect.Data;
+using QuantConnect.Data.Custom.Tiingo;
+using QuantConnect.Data.UniverseSelection;
+using QuantConnect.Securities;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Example algorithm of a custom universe selection using coarse data and adding TiingoNews
+    /// If conditions are met will add the underlying and trade it
+    /// </summary>
+    public class CoarseTiingoNewsUniverseSelectionAlgorithm : QCAlgorithm
+    {
+        private const int NumberOfSymbols = 3;
+        private List<Symbol> _symbols;
+
+        public override void Initialize()
+        {
+            SetStartDate(2014, 03, 24);
+            SetEndDate(2014, 04, 07);
+
+            UniverseSettings.FillForward = false;
+
+            AddUniverse(new CustomDataCoarseFundamentalUniverse(UniverseSettings, SecurityInitializer, CoarseSelectionFunction));
+
+            _symbols = new List<Symbol>();
+        }
+
+        // sort the data by daily dollar volume and take the top 'NumberOfSymbols'
+        public IEnumerable<Symbol> CoarseSelectionFunction(IEnumerable<CoarseFundamental> coarse)
+        {
+            // sort descending by daily dollar volume
+            var sortedByDollarVolume = coarse.OrderByDescending(x => x.DollarVolume);
+
+            // take the top entries from our sorted collection
+            var top = sortedByDollarVolume.Take(NumberOfSymbols);
+
+            // we need to return only the symbol objects
+            return top.Select(x => QuantConnect.Symbol.CreateBase(typeof(TiingoNews), x.Symbol, x.Symbol.ID.Market));
+        }
+
+        public override void OnData(Slice data)
+        {
+            var articles = data.Get<TiingoNews>();
+
+            foreach (var kvp in articles)
+            {
+                var news = kvp.Value;
+                if (news.Title.IndexOf("Stocks Drop", 0, StringComparison.CurrentCultureIgnoreCase) != -1)
+                {
+                    if (!Securities.ContainsKey(kvp.Key.Underlying))
+                    {
+                        // add underlying we want to trade
+                        AddSecurity(kvp.Key.Underlying);
+                        _symbols.Add(kvp.Key.Underlying);
+                    }
+                }
+            }
+
+            foreach (var symbol in _symbols)
+            {
+                if (Securities[symbol].HasData)
+                {
+                    SetHoldings(symbol, 1m / _symbols.Count);
+                }
+            }
+        }
+
+        public override void OnSecuritiesChanged(SecurityChanges changes)
+        {
+            changes.FilterCustomSecurities = false;
+            Log($"{Time} {changes}");
+        }
+
+        private class CustomDataCoarseFundamentalUniverse : CoarseFundamentalUniverse
+        {
+            public CustomDataCoarseFundamentalUniverse(UniverseSettings universeSettings, ISecurityInitializer securityInitializer, Func<IEnumerable<CoarseFundamental>, IEnumerable<Symbol>> selector)
+                : base(universeSettings, securityInitializer, selector)
+            { }
+
+            public override IEnumerable<SubscriptionRequest> GetSubscriptionRequests(Security security, DateTime currentTimeUtc, DateTime maximumEndTimeUtc,
+                ISubscriptionDataConfigService subscriptionService)
+            {
+                var config = subscriptionService.Add(
+                    typeof(TiingoNews),
+                    security.Symbol,
+                    UniverseSettings.Resolution,
+                    UniverseSettings.FillForward,
+                    UniverseSettings.ExtendedMarketHours,
+                    dataNormalizationMode: UniverseSettings.DataNormalizationMode);
+                return new[]{new SubscriptionRequest(isUniverseSubscription: false,
+                    universe: this,
+                    security: security,
+                    configuration: config,
+                    startTimeUtc: currentTimeUtc,
+                    endTimeUtc: maximumEndTimeUtc)};
+            }
+        }
+    }
+}

Algorithm.CSharp/DelistedFutureLiquidateRegressionAlgorithm.cs

@@ -0,0 +1,138 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using QuantConnect.Data;
+using QuantConnect.Interfaces;
+using QuantConnect.Orders;
+using QuantConnect.Securities;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Regression algorithm which reproduces GH issue 4446
+    /// </summary>
+    public class DelistedFutureLiquidateRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Symbol _contractSymbol;
+
+        /// <summary>
+        /// Initialize your algorithm and add desired assets.
+        /// </summary>
+        public override void Initialize()
+        {
+            SetStartDate(2013, 10, 08);
+            SetEndDate(2013, 12, 30);
+
+            var futureSP500 = AddFuture(Futures.Indices.SP500EMini);
+            futureSP500.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 (_contractSymbol == null)
+            {
+                foreach (var chain in slice.FutureChains)
+                {
+                    var contract = chain.Value.OrderBy(x => x.Expiry).FirstOrDefault();
+                    // if found, trade it
+                    if (contract != null)
+                    {
+                        _contractSymbol = contract.Symbol;
+                        MarketOrder(_contractSymbol, 1);
+                    }
+                }
+            }
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            Log($"{_contractSymbol}: {Securities[_contractSymbol].Invested}");
+            if (Securities[_contractSymbol].Invested)
+            {
+                throw new Exception($"Position should be closed when {_contractSymbol} got delisted {_contractSymbol.ID.Date}");
+            }
+        }
+
+        public override void OnOrderEvent(OrderEvent orderEvent)
+        {
+            Log($"{orderEvent}. Delisting on: {_contractSymbol.ID.Date}");
+        }
+
+        /// <summary>
+        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
+        /// </summary>
+        public bool CanRunLocally { get; } = true;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public Language[] Languages { get; } = { Language.CSharp };
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        {
+            {"Total Trades", "2"},
+            {"Average Win", "1.63%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "7.292%"},
+            {"Drawdown", "1.300%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "1.634%"},
+            {"Sharpe Ratio", "2.476"},
+            {"Probabilistic Sharpe Ratio", "92.194%"},
+            {"Loss Rate", "0%"},
+            {"Win Rate", "100%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "0.006"},
+            {"Beta", "0.158"},
+            {"Annual Standard Deviation", "0.032"},
+            {"Annual Variance", "0.001"},
+            {"Information Ratio", "-4.89"},
+            {"Tracking Error", "0.08"},
+            {"Treynor Ratio", "0.509"},
+            {"Total Fees", "$3.70"},
+            {"Fitness Score", "0.019"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "1.362"},
+            {"Return Over Maximum Drawdown", "9.699"},
+            {"Portfolio Turnover", "0.022"},
+            {"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", "-1252326142"}
+        };
+    }
+}

Algorithm.CSharp/EmaCrossFuturesFrontMonthAlgorithm.cs

@@ -0,0 +1,122 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+
+using QuantConnect.Data;
+using QuantConnect.Data.Consolidators;
+using QuantConnect.Data.UniverseSelection;
+using QuantConnect.Indicators;
+using QuantConnect.Securities;
+using System.Linq;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// This example demonstrates how to implement a cross moving average for the futures front contract
+    /// </summary>
+    /// <meta name="tag" content="using data" />
+    /// <meta name="tag" content="indicator" />
+    /// <meta name="tag" content="futures" />
+    public class EmaCrossFuturesFrontMonthAlgorithm : QCAlgorithm
+    {
+        private const decimal _tolerance = 0.001m;
+        private Symbol _symbol;
+        private ExponentialMovingAverage _fast;
+        private ExponentialMovingAverage _slow;
+        private IDataConsolidator _consolidator;
+
+        public override void Initialize()
+        {
+            SetStartDate(2013, 10, 08);
+            SetEndDate(2013, 10, 10);
+            SetCash(1000000);
+
+            var future = AddFuture(Futures.Metals.Gold);
+
+            // Only consider the front month contract
+            // Update the universe once per day to improve performance
+            future.SetFilter(x => x.FrontMonth().OnlyApplyFilterAtMarketOpen());
+
+            // Create two exponential moving averages
+            _fast = new ExponentialMovingAverage(100);
+            _slow = new ExponentialMovingAverage(300);
+
+            // Add a custom chart to track the EMA cross
+            var chart = new Chart("EMA Cross");
+            chart.AddSeries(new Series("Fast", SeriesType.Line, 0));
+            chart.AddSeries(new Series("Slow", SeriesType.Line, 0));
+            AddChart(chart);
+        }
+
+        public override void OnData(Slice slice)
+        {
+            SecurityHolding holding;
+            if (Portfolio.TryGetValue(_symbol, out holding))
+            {
+                // Buy the futures' front contract when the fast EMA is above the slow one
+                if (_fast > _slow * (1 + _tolerance))
+                {
+                    if (!holding.Invested)
+                    {
+                        SetHoldings(_symbol, .1);
+                        PlotEma();
+                    }
+                }
+                else if (holding.Invested)
+                {
+                    Liquidate(_symbol);
+                    PlotEma();
+                }
+            }
+        }
+
+        public override void OnSecuritiesChanged(SecurityChanges changes)
+        {
+            if (changes.RemovedSecurities.Count > 0)
+            {
+                // Remove the consolidator for the previous contract
+                // and reset the indicators
+                if (_symbol != null && _consolidator != null)
+                {
+                    SubscriptionManager.RemoveConsolidator(_symbol, _consolidator);
+                    _fast.Reset();
+                    _slow.Reset();
+                }
+                // We don't need to call Liquidate(_symbol),
+                // since its positions are liquidated because the contract has expired.
+            }
+
+            // Only one security will be added: the new front contract
+            _symbol = changes.AddedSecurities.SingleOrDefault().Symbol;
+
+            // Create a new consolidator and register the indicators to it
+            _consolidator = ResolveConsolidator(_symbol, Resolution.Minute);
+            RegisterIndicator(_symbol, _fast, _consolidator);
+            RegisterIndicator(_symbol, _slow, _consolidator);
+
+            // Warm up the indicators
+            WarmUpIndicator(_symbol, _fast, Resolution.Minute);
+            WarmUpIndicator(_symbol, _slow, Resolution.Minute);
+
+            PlotEma();
+        }
+
+        private void PlotEma()
+        {
+            Plot("EMA Cross", "Fast", _fast);
+            Plot("EMA Cross", "Slow", _slow);
+        }
+    }
+}

Algorithm.CSharp/ExtendedMarketTradingRegressionAlgorithm.cs

@@ -0,0 +1,147 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
+using System;
+using System.Collections.Generic;
+using QuantConnect.Data.Market;
+using QuantConnect.Orders;
+using QuantConnect.Interfaces;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// This algorithm demonstrates extended market hours trading.
+    /// </summary>
+    /// <meta name="tag" content="using data" />
+    /// <meta name="tag" content="assets" />
+    /// <meta name="tag" content="regression test" />
+    public class ExtendedMarketTradingRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private DateTime _lastAction;
+        private Symbol _spy;
+
+        /// <summary>
+        /// Initialise the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must initialized.
+        /// </summary>
+        public override void Initialize()
+        {
+            SetStartDate(2013, 10, 07);  //Set Start Date
+            SetEndDate(2013, 10, 11);    //Set End Date
+            SetCash(100000);             //Set Strategy Cash
+            _spy = AddEquity("SPY", Resolution.Minute, Market.USA, true, 0m, true).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 void OnData(TradeBars data)
+        {
+            //Only take an action once a day.
+            if (_lastAction.Date == Time.Date) return;
+            TradeBar spyBar = data["SPY"];
+
+            //If it isnt during market hours, go ahead and buy ten!
+            if (!InMarketHours())
+            {
+                LimitOrder(_spy, 10, spyBar.Low);
+                _lastAction = Time;
+            }
+        }
+
+        /// <summary>
+        /// Order events are triggered on order status changes. There are many order events including non-fill messages.
+        /// </summary>
+        /// <param name="orderEvent">OrderEvent object with details about the order status</param>
+        public override void OnOrderEvent(OrderEvent orderEvent)
+        {
+            if (InMarketHours())
+            {
+                throw new Exception("Order processed during market hours.");
+            }
+
+            Log($"{orderEvent}");
+        }
+
+        /// <summary>
+        /// Check if we are in Market Hours, NYSE is open from (9:30 am to 4 pm)
+        /// </summary>
+        public bool InMarketHours()
+        {
+            TimeSpan now = Time.TimeOfDay;
+            TimeSpan open = new TimeSpan(09, 30, 0);
+            TimeSpan close = new TimeSpan(16, 0, 0);
+
+            return (open < now) && (close > now);
+        }
+
+        /// <summary>
+        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
+        /// </summary>
+        public bool CanRunLocally { get; } = true;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public Language[] Languages { get; } = { Language.CSharp, Language.Python };
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        {
+            {"Total Trades", "4"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "8.332%"},
+            {"Drawdown", "0.100%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "0.106%"},
+            {"Sharpe Ratio", "7.474"},
+            {"Probabilistic Sharpe Ratio", "85.145%"},
+            {"Loss Rate", "0%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "0.007"},
+            {"Beta", "0.036"},
+            {"Annual Standard Deviation", "0.007"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "-7.03"},
+            {"Tracking Error", "0.186"},
+            {"Treynor Ratio", "1.557"},
+            {"Total Fees", "$4.00"},
+            {"Fitness Score", "0.012"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "38.663"},
+            {"Return Over Maximum Drawdown", "238.773"},
+            {"Portfolio Turnover", "0.012"},
+            {"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", "699698796"}
+        };
+    }
+}

Algorithm.CSharp/QuantConnect.Algorithm.CSharp.csproj

@@ -98,6 +98,16 @@
     <IsLinux>false</IsLinux>
     <IsLinux Condition="'$(IsWindows)' != 'true' AND '$(IsOSX)' != 'true' AND '$([System.Runtime.InteropServices.RuntimeInformation]::IsOSPlatform($([System.Runtime.InteropServices.OSPlatform]::Linux)))' == 'true'">true</IsLinux>
   </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'DebugDocker|AnyCPU'">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>portable</DebugType>
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <LangVersion>6</LangVersion>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>..\QuantConnect.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
   <Target Name="PrintRID" BeforeTargets="Build">
     <Message Text="IsWindows $(IsWindows)" Importance="high" />
     <Message Text="IsOSX $(IsOSX)" Importance="high" />
@@ -148,7 +158,6 @@
     <Compile Include="Alphas\TriangleExchangeRateArbitrageAlpha.cs" />
     <Compile Include="Alphas\TripleLeveragedETFPairVolatilityDecayAlpha.cs" />
     <Compile Include="Alphas\VixDualThrustAlpha.cs" />
-    <Compile Include="AltData\RobintrackHoldingsAlgorithm.cs" />
     <Compile Include="AltData\CachedAlternativeDataAlgorithm.cs" />
     <Compile Include="AltData\BenzingaNewsAlgorithm.cs" />
     <Compile Include="AltData\SECReport8KAlgorithm.cs" />
@@ -158,6 +167,10 @@
     <Compile Include="AltData\TiingoNewsAlgorithm.cs" />
     <Compile Include="AutomaticIndicatorWarmupDataTypeRegressionAlgorithm.cs" />
     <Compile Include="AutomaticIndicatorWarmupRegressionAlgorithm.cs" />
+    <Compile Include="ExtendedMarketTradingRegressionAlgorithm.cs" />
+    <Compile Include="CoarseTiingoNewsUniverseSelectionAlgorithm.cs" />
+    <Compile Include="DelistedFutureLiquidateRegressionAlgorithm.cs" />
+    <Compile Include="EmaCrossFuturesFrontMonthAlgorithm.cs" />
     <Compile Include="OpenInterestFuturesRegressionAlgorithm.cs" />
     <Compile Include="CustomPartialFillModelAlgorithm.cs" />
     <Compile Include="EquityTradeAndQuotesRegressionAlgorithm.cs" />
@@ -354,6 +367,7 @@
     <Compile Include="RegressionAlgorithm.cs" />
     <Compile Include="RenkoConsolidatorAlgorithm.cs" />
     <Compile Include="ScheduledEventsAlgorithm.cs" />
+    <Compile Include="ScheduledQueuingAlgorithm.cs" />
     <Compile Include="StressSymbolsAlgorithm.cs" />
     <Compile Include="StressSymbols.cs" />
     <Compile Include="TickDataFilteringAlgorithm.cs" />

Algorithm.CSharp/ScheduledQueuingAlgorithm.cs

@@ -0,0 +1,96 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using QuantConnect.Algorithm.Framework.Alphas;
+using QuantConnect.Algorithm.Framework.Execution;
+using QuantConnect.Algorithm.Framework.Portfolio;
+using QuantConnect.Algorithm.Framework.Selection;
+using QuantConnect.Data;
+using QuantConnect.Data.Fundamental;
+using QuantConnect.Data.UniverseSelection;
+using QuantConnect.Interfaces;
+using QuantConnect.Securities;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    public class TachyonDynamicGearbox : QCAlgorithm
+    {
+        private int numberOfSymbols;
+        private int numberOfSymbolsFine;
+        private Queue<Symbol> queue;
+        private int dequeueSize;
+        
+
+        public override void Initialize()
+        {
+            SetStartDate(2020, 9, 1);
+            SetEndDate(2020, 9, 2);
+            SetCash(100000);
+            
+            numberOfSymbols = 2000;
+            numberOfSymbolsFine = 1000;
+            SetUniverseSelection(new FineFundamentalUniverseSelectionModel(CoarseSelectionFunction, FineSelectionFunction));
+            
+            SetPortfolioConstruction(new EqualWeightingPortfolioConstructionModel());
+            
+            SetExecution(new ImmediateExecutionModel());
+            
+            queue = new Queue<Symbol>();
+            dequeueSize = 100;
+            
+            AddEquity("SPY", Resolution.Minute);
+            Schedule.On(DateRules.EveryDay("SPY"), TimeRules.At(0, 0), FillQueue);
+            Schedule.On(DateRules.EveryDay("SPY"), TimeRules.Every(TimeSpan.FromMinutes(60)), TakeFromQueue);
+        }
+
+        public IEnumerable<Symbol> CoarseSelectionFunction(IEnumerable<CoarseFundamental> coarse)
+        {
+            var sortedByDollarVolume = coarse
+                .Where(x => x.HasFundamentalData)
+                .OrderByDescending(x => x.DollarVolume);
+            return sortedByDollarVolume.Take(numberOfSymbols).Select(x => x.Symbol);
+        }
+        
+        public IEnumerable<Symbol> FineSelectionFunction(IEnumerable<FineFundamental> fine)
+        {
+            
+            var sortedByPeRatio = fine.OrderByDescending(x => x.ValuationRatios.PERatio);
+            var topFine = sortedByPeRatio.Take(numberOfSymbolsFine);
+            return topFine.Select(x => x.Symbol);
+        }
+        
+        private void FillQueue() {
+            var securities = ActiveSecurities.Values.Where(x => x.Fundamentals != null);
+            
+            // Fill queue with symbols sorted by PE ratio (decreasing order)
+            queue.Clear();
+            var sortedByPERatio = securities.OrderByDescending(x => x.Fundamentals.ValuationRatios.PERatio);
+            foreach (Security security in sortedByPERatio)
+                queue.Enqueue(security.Symbol);
+        }
+        
+        private void TakeFromQueue() {
+            List<Symbol> symbols = new List<Symbol>();
+            for (int i = 0; i < Math.Min(dequeueSize, queue.Count); i++)
+                symbols.Add(queue.Dequeue());
+            History(symbols, 10, Resolution.Daily);
+            
+            Log("Symbols at " + Time + ": " + string.Join(", ", symbols.Select(x => x.ToString())));
+        }
+    }
+}

Algorithm.CSharp/UniverseSharingSecurityDifferentSubscriptionRequestRegressionAlgorithm.cs

@@ -152,8 +152,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Beta", "0"},
             {"Annual Standard Deviation", "0"},
             {"Annual Variance", "0"},
-            {"Information Ratio", "-31.646"},
-            {"Tracking Error", "0.16"},
+            {"Information Ratio", "-58.133"},
+            {"Tracking Error", "0.173"},
             {"Treynor Ratio", "0"},
             {"Total Fees", "$0.00"},
             {"Fitness Score", "0"},

Algorithm.Framework/Portfolio/SectorWeightingPortfolioConstructionModel.cs

@@ -71,6 +71,7 @@ namespace QuantConnect.Algorithm.Framework.Portfolio
 
         /// <summary>
         /// Initialize a new instance of <see cref="SectorWeightingPortfolioConstructionModel"/>
+        /// </summary>
         /// <param name="rebalance">Rebalancing func or if a date rule, timedelta will be converted into func.
         /// For a given algorithm UTC DateTime the func returns the next expected rebalance time
         /// or null if unknown, in which case the function will be called again in the next loop. Returning current time

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

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

Algorithm.Python/.idea/misc.xml

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

Algorithm.Python/.idea/modules.xml

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

Algorithm.Python/.vscode/settings.json

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

Algorithm.Python/AltData/RobintrackHoldingsAlgorithm.py

@@ -1,64 +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.
-
-from clr import AddReference
-AddReference("System")
-AddReference("QuantConnect.Algorithm")
-AddReference("QuantConnect.Common")
-
-from datetime import datetime, timedelta
-
-from System import *
-from QuantConnect import *
-from QuantConnect.Algorithm import *
-from QuantConnect.Data import *
-from QuantConnect.Data.Custom.Robintrack import *
-
-### <summary>
-### Looks at users holding the stock AAPL at a given point in time
-### and keeps track of changes in retail investor sentiment.
-###
-### We go long if the sentiment increases by 0.5%, and short if it decreases by -0.5%
-### </summary>
-class RobintrackHoldingsAlgorithm(QCAlgorithm):
-
-    def Initialize(self):
-        self.lastValue = 0
-
-        self.SetStartDate(2018, 5, 1)
-        self.SetEndDate(2020, 5, 5)
-        self.SetCash(100000)
-
-        self.aapl = self.AddEquity("AAPL", Resolution.Daily).Symbol
-        self.aaplHoldings = self.AddData(RobintrackHoldings, self.aapl).Symbol
-        self.isLong = False
-
-    def OnData(self, data):
-        for kvp in data.Get(RobintrackHoldings):
-            holdings = kvp.Value
-
-            if self.lastValue != 0:
-                percentChange = (holdings.UsersHolding - self.lastValue) / self.lastValue
-                holdingInfo = f"There are {holdings.UsersHolding} unique users holding {kvp.Key.Underlying} - users holding % of U.S. equities universe: {holdings.UniverseHoldingPercent * 100.0}%"
-
-                if percentChange >= 0.005 and not self.isLong:
-                    self.Log(f"{self.UtcTime} - Buying AAPL - {holdingInfo}")
-                    self.SetHoldings(self.aapl, 0.5)
-                    self.isLong = True
-
-                elif percentChange <= -0.005 and self.isLong:
-                    self.Log(f"{self.UtcTime} - Shorting AAPL - {holdingInfo}")
-                    self.SetHoldings(self.aapl, -0.5)
-                    self.isLong = False
-
-            self.lastValue = holdings.UsersHolding;

Algorithm.Python/BasicTemplateOptionsFilterUniverseAlgorithm.py

@@ -33,40 +33,39 @@ class BasicTemplateOptionsFilterUniverseAlgorithm(QCAlgorithm):
     UnderlyingTicker = "GOOG"
 
     def Initialize(self):
-        self.SetStartDate(2015, 12, 16)
+        self.SetStartDate(2015, 12, 24)
         self.SetEndDate(2015, 12, 24)
         self.SetCash(100000)
 
-        equity = self.AddEquity(self.UnderlyingTicker);
+        equity = self.AddEquity(self.UnderlyingTicker)
         option = self.AddOption(self.UnderlyingTicker)
-        self.option_symbol = option.Symbol
+        self.OptionSymbol = option.Symbol
 
-        # set our strike/expiry filter for this option chain
-        # SetFilter method accepts timedelta objects or integer for days.
-        # The following statements yield the same filtering criteria
-        option.SetFilter(-10, +10, 0, 10)
-        # option.SetFilter(-10, 10, timedelta(0), timedelta(10))
+        # Set our custom universe filter
+        option.SetFilter(self.FilterFunction)
 
         # use the underlying equity as the benchmark
         self.SetBenchmark(equity.Symbol)
 
+    def FilterFunction(self, universe):
+        #Expires today, is a call, and is within 10 dollars of the current price
+        universe = universe.WeeklysOnly().Expiration(0, 1)
+        return [symbol for symbol in universe 
+                if symbol.ID.OptionRight != OptionRight.Put 
+                and -10 < universe.Underlying.Price - symbol.ID.StrikePrice < 10]
+
     def OnData(self,slice):
         if self.Portfolio.Invested: return
 
         for kvp in slice.OptionChains:
-            if kvp.Key != self.option_symbol: continue
-            chain = kvp.Value
-            # find the call options expiring today
-            contracts = [i for i in chain if i.Right ==  OptionRight.Call and i.Expiry.date() == self.Time.date()]
-            # sorted the contracts by their strike, find the second strike under market price 
-            sorted_contracts = [i for i in sorted(contracts, key = lambda x:x.Strike, reverse = True) if i.Strike < chain.Underlying.Price]
-            # if found, trade it
-            if len(sorted_contracts) == 0: 
-                self.Log("No call contracts expiring today")
-                return
-            self.MarketOrder(sorted_contracts[1].Symbol, 1)
+            
+            if kvp.Key != self.OptionSymbol: continue
 
-    def OnOrderEvent(self, orderEvent):
-        # Order fill event handler. On an order fill update the resulting information is passed to this method.
-        # <param name="orderEvent">Order event details containing details of the evemts</param>
-        self.Log(str(orderEvent))
+            # Get the first call strike under market price expiring today
+            chain = kvp.Value
+            contracts = [option for option in sorted(chain, key = lambda x:x.Strike, reverse = True)
+                         if option.Expiry.date() == self.Time.date()
+                         and option.Strike < chain.Underlying.Price]
+            
+            if contracts:
+                self.MarketOrder(contracts[0].Symbol, 1)

Algorithm.Python/CoarseTiingoNewsUniverseSelectionAlgorithm.py

@@ -0,0 +1,76 @@
+# QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+# Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from clr import AddReference
+AddReference("System.Core")
+AddReference("QuantConnect.Common")
+AddReference("QuantConnect.Algorithm")
+
+from System import *
+from QuantConnect import *
+from QuantConnect.Algorithm import QCAlgorithm
+from QuantConnect.Data.UniverseSelection import *
+from QuantConnect.Data.Custom.Tiingo import *
+
+### <summary>
+### Example algorithm of a custom universe selection using coarse data and adding TiingoNews
+### If conditions are met will add the underlying and trade it
+### </summary>
+class CoarseTiingoNewsUniverseSelectionAlgorithm(QCAlgorithm):
+
+    def Initialize(self):
+        '''Initialise the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must initialized.'''
+
+        self.SetStartDate(2014,3,24)
+        self.SetEndDate(2014,4,7)
+        
+        self.UniverseSettings.FillForward = False;
+
+        self.__numberOfSymbols = 3
+        
+        self.AddUniverse(CustomDataCoarseFundamentalUniverse(self.UniverseSettings, self.SecurityInitializer, self.CoarseSelectionFunction));
+
+        self._symbols = []
+
+    # sort the data by daily dollar volume and take the top 'NumberOfSymbols'
+    def CoarseSelectionFunction(self, coarse):
+        # sort descending by daily dollar volume
+        sortedByDollarVolume = sorted(coarse, key=lambda x: x.DollarVolume, reverse=True)
+
+        # return the symbol objects of the top entries from our sorted collection
+        return [ Symbol.CreateBase(TiingoNews, x.Symbol, x.Symbol.ID.Market) for x in sortedByDollarVolume[:self.__numberOfSymbols] ]
+
+    def OnData(self, data):
+        articles = data.Get(TiingoNews)
+
+        for kvp in articles:
+            news = kvp.Value
+            if "stocks drop" in news.Title.lower():
+                if not self.Securities.ContainsKey(kvp.Key.Underlying):
+                    # add underlying we want to trade
+                    self.AddSecurity(kvp.Key.Underlying)
+                    self._symbols.append(kvp.Key.Underlying)
+
+        for symbol in self._symbols:
+            if self.Securities[symbol].HasData:
+                self.SetHoldings(symbol, 1.0 / len(self._symbols))
+
+    def OnSecuritiesChanged(self,  changes):
+        changes.FilterCustomSecurities = False
+        self.Log(f"{self.Time} {changes}")
+
+class CustomDataCoarseFundamentalUniverse(CoarseFundamentalUniverse):
+    def GetSubscriptionRequests(self, security, currentTimeUtc, maximumEndTimeUtc, subscriptionService):
+        us = self.UniverseSettings
+        config = subscriptionService.Add(TiingoNews, security.Symbol, us.Resolution, us.FillForward, us.ExtendedMarketHours, True, False, False, us.DataNormalizationMode)
+        return [ SubscriptionRequest(False, self, security, config, currentTimeUtc, maximumEndTimeUtc) ]

Algorithm.Python/CustomConsolidatorRegressionAlgorithm.py

@@ -0,0 +1,180 @@
+# QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+# Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from clr import AddReference
+AddReference("System")
+AddReference("QuantConnect.Algorithm")
+AddReference("QuantConnect.Indicators")
+AddReference("QuantConnect.Common")
+
+from System import *
+from QuantConnect import *
+from QuantConnect.Python import *
+from QuantConnect.Algorithm import *
+from QuantConnect.Algorithm.Framework.Selection import *
+from QuantConnect.Data import *
+from QuantConnect.Data.Consolidators import *
+from QuantConnect.Indicators import *
+from QuantConnect.Data.Market import *
+from datetime import *
+
+class CustomConsolidatorRegressionAlgorithm(QCAlgorithm):
+    '''Custom Consolidator Regression Algorithm shows some examples of how to build custom 
+    consolidators in Python.'''
+
+    def Initialize(self):
+        self.SetStartDate(2013,10,4)  
+        self.SetEndDate(2013,10,11)    
+        self.SetCash(100000)  
+        self.AddEquity("SPY", Resolution.Minute)
+
+        #Create 5 day QuoteBarConsolidator; set consolidated function; add to subscription manager
+        fiveDayConsolidator = QuoteBarConsolidator(timedelta(days=5))
+        fiveDayConsolidator.DataConsolidated += self.OnQuoteBarDataConsolidated
+        self.SubscriptionManager.AddConsolidator("SPY", fiveDayConsolidator)
+
+        #Create a 3:10PM custom quote bar consolidator
+        timedConsolidator = DailyTimeQuoteBarConsolidator(time(hour=15, minute=10))
+        timedConsolidator.DataConsolidated += self.OnQuoteBarDataConsolidated
+        self.SubscriptionManager.AddConsolidator("SPY", timedConsolidator)
+
+        #Create our entirely custom 2 day quote bar consolidator
+        self.customConsolidator = CustomQuoteBarConsolidator(timedelta(days=2))
+        self.customConsolidator.DataConsolidated += (self.OnQuoteBarDataConsolidated)
+        self.SubscriptionManager.AddConsolidator("SPY", self.customConsolidator)
+
+        #Create an indicator and register a consolidator to it
+        self.movingAverage = SimpleMovingAverage(5)
+        self.customConsolidator2 = CustomQuoteBarConsolidator(timedelta(hours=1))
+        self.RegisterIndicator("SPY", self.movingAverage, self.customConsolidator2)
+
+
+    def OnQuoteBarDataConsolidated(self, sender, bar):
+        '''Function assigned to be triggered by consolidators.
+        Designed to post debug messages to show how the examples work, including
+        which consolidator is posting, as well as its values.
+
+        If using an inherited class and not overwriting OnDataConsolidated
+        we expect to see the super C# class as the sender type.
+
+        Using sender.Period only works when all consolidators have a Period value.
+        '''
+        
+        consolidatorInfo = str(type(sender)) + str(sender.Period)
+       
+        self.Debug("Bar Type: " + consolidatorInfo)
+        self.Debug("Bar Range: " + bar.Time.ctime() + " - " + bar.EndTime.ctime())
+        self.Debug("Bar value: " + str(bar.Close))
+    
+    def OnData(self, slice):
+        test = slice.get_Values()
+
+        if self.customConsolidator.Consolidated and slice.ContainsKey("SPY"):
+            data = slice['SPY']
+            
+            if self.movingAverage.IsReady:
+                if data.Value > self.movingAverage.Current.Price:
+                    self.SetHoldings("SPY", .5)
+                else :
+                    self.SetHoldings("SPY", 0)
+            
+
+
+class DailyTimeQuoteBarConsolidator(QuoteBarConsolidator):
+    '''A custom QuoteBar consolidator that inherits from C# class QuoteBarConsolidator. 
+
+    This class shows an example of building on top of an existing consolidator class, it is important
+    to note that this class can leverage the functions of QuoteBarConsolidator but its private fields
+    (_period, _workingbar, etc.) are separate from this Python. For that reason if we want Scan() to work
+    we must overwrite the function with our desired Scan function and trigger OnDataConsolidated().
+    
+    For this particular example we implemented the scan method to trigger a consolidated bar
+    at closeTime everyday'''
+
+    def __init__(self, closeTime):
+        self.closeTime = closeTime
+        self.workingBar = None
+    
+    def Update(self, data):
+        '''Updates this consolidator with the specified data'''
+
+        #If we don't have bar yet, create one
+        if self.workingBar is None:
+            self.workingBar = QuoteBar(data.Time,data.Symbol,data.Bid,data.LastBidSize,
+                data.Ask,data.LastAskSize)
+
+        #Update bar using QuoteBarConsolidator's AggregateBar()
+        self.AggregateBar(self.workingBar, data)
+        
+
+    def Scan(self, time):
+        '''Scans this consolidator to see if it should emit a bar due yet'''
+
+        #If its our desired bar end time take the steps to 
+        if time.hour == self.closeTime.hour and time.minute == self.closeTime.minute:
+
+            #Set end time
+            self.workingBar.EndTime = time
+
+            #Emit event using QuoteBarConsolidator's OnDataConsolidated()
+            self.OnDataConsolidated(self.workingBar)
+
+            #Reset the working bar to None
+            self.workingBar = None
+
+class CustomQuoteBarConsolidator(PythonConsolidator):
+    '''A custom quote bar consolidator that inherits from PythonConsolidator and implements 
+    the IDataConsolidator interface, it must implement all of IDataConsolidator. Reference 
+    PythonConsolidator.cs and DataConsolidatorPythonWrapper.py for more information.
+
+    This class shows how to implement a consolidator from scratch in Python, this gives us more
+    freedom to determine the behavior of the consolidator but can't leverage any of the built in
+    functions of an inherited class.
+    
+    For this example we implemented a Quotebar from scratch'''
+
+    def __init__(self, period):
+
+        #IDataConsolidator required vars for all consolidators
+        self.Consolidated = None        #Most recently consolidated piece of data.
+        self.WorkingData = None         #Data being currently consolidated
+        self.InputType = QuoteBar       #The type consumed by this consolidator
+        self.OutputType = QuoteBar      #The type produced by this consolidator
+
+        #Consolidator Variables
+        self.Period = period
+    
+    def Update(self, data):
+        '''Updates this consolidator with the specified data'''
+        
+        #If we don't have bar yet, create one
+        if self.WorkingData is None:
+            self.WorkingData = QuoteBar(data.Time,data.Symbol,data.Bid,data.LastBidSize,
+                data.Ask,data.LastAskSize,self.Period)
+
+        #Update bar using QuoteBar's update()
+        self.WorkingData.Update(data.Value, data.Bid.Close, data.Ask.Close, 0, 
+            data.LastBidSize, data.LastAskSize)
+
+    def Scan(self, time):
+        '''Scans this consolidator to see if it should emit a bar due to time passing'''
+
+        if self.Period is not None and self.WorkingData is not None:
+            if time - self.WorkingData.Time >= self.Period:
+
+                #Trigger the event handler with a copy of self and the data
+                self.OnDataConsolidated(self, self.WorkingData)
+
+                #Set the most recent consolidated piece of data and then clear the workingData
+                self.Consolidated = self.WorkingData
+                self.WorkingData = None

Algorithm.Python/EmaCrossFuturesFrontMonthAlgorithm.py

@@ -0,0 +1,101 @@
+# QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+# Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from clr import AddReference
+AddReference("System")
+AddReference("QuantConnect.Algorithm")
+AddReference("QuantConnect.Common")
+AddReference("QuantConnect.Indicators")
+
+from System import *
+from QuantConnect import *
+from QuantConnect.Data.Market import *
+from QuantConnect.Algorithm import *
+from QuantConnect.Indicators import *
+from QuantConnect.Securities import *
+
+### <summary>
+### This example demonstrates how to implement a cross moving average for the futures front contract
+### </summary>
+### <meta name="tag" content="using data" />
+### <meta name="tag" content="indicator" />
+### <meta name="tag" content="futures" />
+class EmaCrossFuturesFrontMonthAlgorithm(QCAlgorithm):
+
+    def Initialize(self):
+        self.SetStartDate(2013, 10, 8)
+        self.SetEndDate(2013, 10, 10)
+        self.SetCash(1000000)
+
+        future = self.AddFuture(Futures.Metals.Gold);
+
+        # Only consider the front month contract
+        # Update the universe once per day to improve performance
+        future.SetFilter(lambda x: x.FrontMonth().OnlyApplyFilterAtMarketOpen())
+
+        # Symbol of the current contract
+        self.symbol = None
+
+        # Create two exponential moving averages
+        self.fast = ExponentialMovingAverage(100)
+        self.slow = ExponentialMovingAverage(300)
+        self.tolerance = 0.001
+        self.consolidator = None
+
+        # Add a custom chart to track the EMA cross
+        chart = Chart('EMA Cross')
+        chart.AddSeries(Series('Fast', SeriesType.Line, 0))
+        chart.AddSeries(Series('Slow', SeriesType.Line, 0))
+        self.AddChart(chart)
+
+    def OnData(self,slice):
+
+        holding = None if self.symbol is None else self.Portfolio.get(self.symbol)
+        if holding is not None:
+            # Buy the futures' front contract when the fast EMA is above the slow one
+            if self.fast.Current.Value > self.slow.Current.Value * (1 + self.tolerance):
+                if not holding.Invested:
+                    self.SetHoldings(self.symbol, .1)
+                    self.PlotEma()
+            elif holding.Invested:
+                self.Liquidate(self.symbol)
+                self.PlotEma()
+
+    def OnSecuritiesChanged(self, changes):
+        if len(changes.RemovedSecurities) > 0:
+            # Remove the consolidator for the previous contract
+            # and reset the indicators
+            if self.symbol is not None and self.consolidator is not None:
+                self.SubscriptionManager.RemoveConsolidator(self.symbol, self.consolidator)
+                self.fast.Reset()
+                self.slow.Reset()
+            # We don't need to call Liquidate(_symbol),
+            # since its positions are liquidated because the contract has expired.
+
+        # Only one security will be added: the new front contract
+        self.symbol = changes.AddedSecurities[0].Symbol
+
+        # Create a new consolidator and register the indicators to it
+        self.consolidator = self.ResolveConsolidator(self.symbol, Resolution.Minute)
+        self.RegisterIndicator(self.symbol, self.fast, self.consolidator)
+        self.RegisterIndicator(self.symbol, self.slow, self.consolidator)
+
+        #  Warm up the indicators
+        self.WarmUpIndicator(self.symbol, self.fast, Resolution.Minute)
+        self.WarmUpIndicator(self.symbol, self.slow, Resolution.Minute)
+
+        self.PlotEma()
+
+    def PlotEma(self):
+        self.Plot('EMA Cross', 'Fast', self.fast.Current.Value)
+        self.Plot('EMA Cross', 'Slow', self.slow.Current.Value)

Algorithm.Python/ExtendedMarketTradingRegressionAlgorithm.py

@@ -0,0 +1,64 @@
+# QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+# Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from clr import AddReference
+AddReference("System")
+AddReference("QuantConnect.Common")
+AddReference("QuantConnect.Algorithm")
+
+import datetime
+from System import *
+from QuantConnect import *
+from QuantConnect.Orders import *
+from QuantConnect.Algorithm import QCAlgorithm
+
+### <summary>
+### This algorithm demonstrates extended market hours trading.
+### </summary>
+### <meta name="tag" content="using data" />
+### <meta name="tag" content="assets" />
+### <meta name="tag" content="regression test" />
+class ExtendedMarketTradingRegressionAlgorithm(QCAlgorithm):
+
+    def Initialize(self):
+        '''Initialise the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must initialized.'''
+        self.SetStartDate(2013,10,7)   #Set Start Date
+        self.SetEndDate(2013,10,11)    #Set End Date
+        self.SetCash(100000)           #Set Strategy Cash
+        # Find more symbols here: http://quantconnect.com/data
+        self.spy = self.AddEquity("SPY", Resolution.Minute, Market.USA, True, 1, True)
+
+        self._lastAction = None
+
+    def OnData(self, data):
+        '''OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here.'''
+        if self._lastAction is not None and self._lastAction.date() == self.Time.date():
+            return
+
+        spyBar = data.Bars['SPY']
+
+        if not self.InMarketHours():
+            self.LimitOrder("SPY", 10, spyBar.Low);
+            self._lastAction = self.Time
+
+    def OnOrderEvent(self, orderEvent):
+        self.Log(str(orderEvent))
+        if self.InMarketHours():
+            raise Exception("Order processed during market hours.")
+
+    def InMarketHours(self):
+        now = self.Time.time()
+        open = datetime.time(9,30,0)
+        close = datetime.time(16,0,0)
+        return (open < now) and (close > now)
+

Algorithm.Python/FilterUniverseRegressionAlgorithm.py

@@ -0,0 +1,65 @@
+# QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+# Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from clr import AddReference
+AddReference("System")
+AddReference("QuantConnect.Algorithm")
+AddReference("QuantConnect.Common")
+
+from System import *
+from QuantConnect import *
+from QuantConnect.Algorithm import *
+from datetime import timedelta
+
+### <summary>
+### This regression algorithm is for testing a custom Python filter for options
+### that returns a OptionFilterUniverse.
+### </summary>
+### <meta name="tag" content="options" />
+### <meta name="tag" content="filter selection" />
+### <meta name="tag" content="regression test" />
+class FilterUniverseRegressionAlgorithm(QCAlgorithm):
+    UnderlyingTicker = "GOOG"
+
+    def Initialize(self):
+        self.SetStartDate(2015, 12, 24)
+        self.SetEndDate(2015, 12, 24)
+        self.SetCash(100000)
+
+        equity = self.AddEquity(self.UnderlyingTicker)
+        option = self.AddOption(self.UnderlyingTicker)
+        self.OptionSymbol = option.Symbol
+
+        # Set our custom universe filter
+        option.SetFilter(self.FilterFunction)
+
+        # use the underlying equity as the benchmark
+        self.SetBenchmark(equity.Symbol)
+
+    def FilterFunction(self, universe):
+        universe = universe.WeeklysOnly().Strikes(-5, +5).CallsOnly().Expiration(0, 1)
+        return universe
+
+    def OnData(self,slice):
+        if self.Portfolio.Invested: return
+
+        for kvp in slice.OptionChains:
+            
+            if kvp.Key != self.OptionSymbol: continue
+
+            chain = kvp.Value
+            contracts = [option for option in sorted(chain, key = lambda x:x.Strike, reverse = True)]
+            
+            if contracts:
+                self.MarketOrder(contracts[0].Symbol, 1)
+

Algorithm.Python/QuantConnect.Algorithm.Python.csproj

@@ -61,7 +61,6 @@
     <Content Include="Alphas\ShareClassMeanReversionAlpha.py" />
     <Content Include="Alphas\TripleLeverageETFPairVolatilityDecayAlpha.py" />
     <Content Include="Alphas\VIXDualThrustAlpha.py" />
-    <Content Include="AltData\RobintrackHoldingsAlgorithm.py" />
     <Content Include="AltData\CachedAlternativeDataAlgorithm.py" />
     <Content Include="AltData\BenzingaNewsAlgorithm.py" />
     <Content Include="AltData\SECReport8KAlgorithm.py" />
@@ -84,11 +83,15 @@
     <None Include="BasicTemplateOptionsPriceModel.py" />
     <Content Include="Benchmarks\SECReportBenchmarkAlgorithm.py" />
     <Content Include="Benchmarks\SmartInsiderEventBenchmarkAlgorithm.py" />
+    <Content Include="CoarseTiingoNewsUniverseSelectionAlgorithm.py" />
     <Content Include="ConsolidateRegressionAlgorithm.py" />
+    <Content Include="CustomConsolidatorRegressionAlgorithm.py" />
     <Content Include="CustomDataAddDataOnSecuritiesChangedRegressionAlgorithm.py" />
     <Content Include="CustomDataAddDataCoarseSelectionRegressionAlgorithm.py" />
     <Content Include="DynamicSecurityDataAlgorithm.py" />
     <Content Include="ConfidenceWeightedFrameworkAlgorithm.py" />
+    <Content Include="ExtendedMarketTradingRegressionAlgorithm.py" />
+    <Content Include="FilterUniverseRegressionAlgorithm.py" />
     <Content Include="FineFundamentalFilteredUniverseRegressionAlgorithm.py" />
     <Content Include="KerasNeuralNetworkAlgorithm.py" />
     <Content Include="CustomDataUsingMapFileRegressionAlgorithm.py" />
@@ -185,6 +188,7 @@
     <None Include="DropboxBaseDataUniverseSelectionAlgorithm.py" />
     <None Include="DropboxUniverseSelectionAlgorithm.py" />
     <None Include="DropboxCoarseFineAlgorithm.py" />
+    <None Include="EmaCrossFuturesFrontMonthAlgorithm.py" />
     <None Include="EmaCrossUniverseSelectionAlgorithm.py" />
     <None Include="EmaCrossUniverseSelectionFrameworkAlgorithm.py" />
     <None Include="ETFGlobalRotationAlgorithm.py" />
@@ -223,6 +227,7 @@
     <None Include="RenkoConsolidatorAlgorithm.py" />
     <None Include="RollingWindowAlgorithm.py" />
     <None Include="ScheduledEventsAlgorithm.py" />
+    <None Include="ScheduledQueuingAlgorithm.py" />
     <None Include="ScheduledUniverseSelectionModelRegressionAlgorithm.py" />
     <None Include="SectorExposureRiskFrameworkAlgorithm.py" />
     <None Include="StandardDeviationExecutionModelRegressionAlgorithm.py" />

Algorithm.Python/QuantConnect.Algorithm.PythonTools.pyproj

@@ -6,8 +6,7 @@
     <ProjectHome>.</ProjectHome>
     <StartupFile>
     </StartupFile>
-    <SearchPath>
-    </SearchPath>
+    <SearchPath>stubs</SearchPath>
     <WorkingDirectory>.</WorkingDirectory>
     <OutputPath>.</OutputPath>
     <Name>QuantConnect.Algorithm.PythonTools</Name>
@@ -88,6 +87,7 @@
     <Compile Include="DropboxCoarseFineAlgorithm.py" />
     <Compile Include="DropboxUniverseSelectionAlgorithm.py" />
     <Compile Include="DynamicSecurityDataAlgorithm.py" />
+    <Compile Include="EmaCrossFuturesFrontMonthAlgorithm.py" />
     <Compile Include="EmaCrossUniverseSelectionAlgorithm.py" />
     <Compile Include="EmaCrossUniverseSelectionFrameworkAlgorithm.py" />
     <Compile Include="ETFGlobalRotationAlgorithm.py" />
@@ -133,7 +133,6 @@
     <Compile Include="PearsonCorrelationPairsTradingAlphaModelFrameworkAlgorithm.py" />
     <Compile Include="PortfolioRebalanceOnCustomFuncRegressionAlgorithm.py" />
     <Compile Include="PortfolioRebalanceOnDateRulesRegressionAlgorithm.py" />
-    <Compile Include="PsychSignalSentimentRegressionAlgorithm.py" />
     <Compile Include="PythonDictionaryFeatureRegressionAlgorithm.py" />
     <Compile Include="PytorchNeuralNetworkAlgorithm.py" />
     <Compile Include="QuandlFuturesDataAlgorithm.py" />

Algorithm.Python/ScheduledQueuingAlgorithm.py

@@ -0,0 +1,76 @@
+# QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+# Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from clr import AddReference
+AddReference("System")
+AddReference("QuantConnect.Algorithm")
+AddReference("QuantConnect.Algorithm.Framework")
+AddReference("QuantConnect.Common")
+
+from System import *
+from QuantConnect import *
+from QuantConnect.Orders import *
+from QuantConnect.Algorithm import *
+from QuantConnect.Algorithm.Framework import *
+from QuantConnect.Algorithm.Framework.Alphas import *
+from QuantConnect.Algorithm.Framework.Execution import *
+from QuantConnect.Algorithm.Framework.Portfolio import *
+from QuantConnect.Algorithm.Framework.Selection import *
+
+from queue import Queue
+
+class ScheduledQueuingAlgorithm(QCAlgorithm):
+
+    def Initialize(self):
+        self.SetStartDate(2020, 9, 1)
+        self.SetEndDate(2020, 9, 2)
+        self.SetCash(100000)
+        
+        self.__numberOfSymbols = 2000
+        self.__numberOfSymbolsFine = 1000
+        self.SetUniverseSelection(FineFundamentalUniverseSelectionModel(self.CoarseSelectionFunction, self.FineSelectionFunction, None, None))
+        
+        self.SetPortfolioConstruction(EqualWeightingPortfolioConstructionModel())
+        
+        self.SetExecution(ImmediateExecutionModel())
+        
+        self.queue = Queue()
+        self.dequeue_size = 100
+        
+        self.AddEquity("SPY", Resolution.Minute)
+        self.Schedule.On(self.DateRules.EveryDay("SPY"), self.TimeRules.At(0, 0), self.FillQueue)
+        self.Schedule.On(self.DateRules.EveryDay("SPY"), self.TimeRules.Every(timedelta(minutes=60)), self.TakeFromQueue)
+
+    def CoarseSelectionFunction(self, coarse):
+        has_fundamentals = [security for security in coarse if security.HasFundamentalData]
+        sorted_by_dollar_volume = sorted(has_fundamentals, key=lambda x: x.DollarVolume, reverse=True)
+        return [ x.Symbol for x in sorted_by_dollar_volume[:self.__numberOfSymbols] ]
+    
+    def FineSelectionFunction(self, fine):
+        sorted_by_pe_ratio = sorted(fine, key=lambda x: x.ValuationRatios.PERatio, reverse=True)
+        return [ x.Symbol for x in sorted_by_pe_ratio[:self.__numberOfSymbolsFine] ]
+        
+    def FillQueue(self):
+        securities = [security for security in self.ActiveSecurities.Values if security.Fundamentals is not None]
+        
+        # Fill queue with symbols sorted by PE ratio (decreasing order)
+        self.queue.queue.clear()
+        sorted_by_pe_ratio = sorted(securities, key=lambda x: x.Fundamentals.ValuationRatios.PERatio, reverse=True)
+        for security in sorted_by_pe_ratio:
+            self.queue.put(security.Symbol)
+        
+    def TakeFromQueue(self):
+        symbols = [self.queue.get() for _ in range(min(self.dequeue_size, self.queue.qsize()))]
+        self.History(symbols, 10, Resolution.Daily)
+        
+        self.Log(f"Symbols at {self.Time}: {[str(symbol) for symbol in symbols]}")

Algorithm.Python/SliceGetByTypeRegressionAlgorithm.py

@@ -19,6 +19,7 @@ AddReference("QuantConnect.Common")
 from System import *
 from QuantConnect import *
 from QuantConnect.Algorithm import *
+from QuantConnect.Data import *
 from QuantConnect.Data.Market import *
 from QuantConnect.Algorithm.Framework.Alphas import *
 from datetime import timedelta

Algorithm.Python/readme.md

@@ -13,14 +13,14 @@ Before we enable python support, follow the [installation instructions](https://
    3. Click **New**. 
         - Name of the variable: `PYTHONHOME`. 
         - Value of the variable: python installation path.
-4. Install [pandas=0.23.4](https://pandas.pydata.org/) and its [dependencies](https://pandas.pydata.org/pandas-docs/stable/install.html#dependencies).
+4. Install [pandas=0.25.3](https://pandas.pydata.org/) and its [dependencies](https://pandas.pydata.org/pandas-docs/stable/install.html#dependencies).
 5. Install [wrapt=1.11.2](https://pypi.org/project/wrapt/) module.
 6. Reboot computer to ensure changes are propogated.
 
 #### [macOS](https://github.com/QuantConnect/Lean#macos)
 
 1. Use the macOS x86-64 package installer from [Anaconda](https://repo.anaconda.com/archive/Anaconda3-5.2.0-MacOSX-x86_64.pkg) and follow "[Installing on macOS](https://docs.anaconda.com/anaconda/install/mac-os)" instructions from Anaconda documentation page.
-2. Install [pandas=0.23.4](https://pandas.pydata.org/) and its [dependencies](https://pandas.pydata.org/pandas-docs/stable/install.html#dependencies).
+2. Install [pandas=0.25.3](https://pandas.pydata.org/) and its [dependencies](https://pandas.pydata.org/pandas-docs/stable/install.html#dependencies).
 3. Install [wrapt=1.11.2](https://pypi.org/project/wrapt/) module.
 
 *Note:* If you encounter the "System.DllNotFoundException: python3.6m" runtime error when running Python algorithms on macOS:
@@ -46,7 +46,7 @@ rm -rf Miniconda3-4.5.12-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 cython=0.29.11
-conda install -y pandas=0.23.4
+conda install -y pandas=0.25.3
 conda install -y wrapt=1.11.2
 ```
 

Algorithm.Python/stubs/QuantConnect/API/__init__.py

@@ -0,0 +1,402 @@
+# encoding: utf-8
+# module QuantConnect.API calls itself API
+# from QuantConnect.Common, Version=2.4.0.0, Culture=neutral, PublicKeyToken=null
+# by generator 1.145
+# no doc
+
+# imports
+import datetime
+import Newtonsoft.Json
+import Newtonsoft.Json.Linq
+import QuantConnect
+import QuantConnect.API
+import QuantConnect.Packets
+import System
+import typing
+
+# no functions
+# classes
+
+class BaseLiveAlgorithmSettings(System.object):
+    """
+    Base class for settings that must be configured per Brokerage to create new algorithms via the API.
+    
+    BaseLiveAlgorithmSettings(user: str, password: str, environment: BrokerageEnvironment, account: str)
+    BaseLiveAlgorithmSettings(user: str, password: str)
+    BaseLiveAlgorithmSettings(environment: BrokerageEnvironment, account: str)
+    BaseLiveAlgorithmSettings(account: str)
+    """
+    @typing.overload
+    def __init__(self, user: str, password: str, environment: QuantConnect.BrokerageEnvironment, account: str) -> QuantConnect.API.BaseLiveAlgorithmSettings:
+        pass
+
+    @typing.overload
+    def __init__(self, user: str, password: str) -> QuantConnect.API.BaseLiveAlgorithmSettings:
+        pass
+
+    @typing.overload
+    def __init__(self, environment: QuantConnect.BrokerageEnvironment, account: str) -> QuantConnect.API.BaseLiveAlgorithmSettings:
+        pass
+
+    @typing.overload
+    def __init__(self, account: str) -> QuantConnect.API.BaseLiveAlgorithmSettings:
+        pass
+
+    def __init__(self, *args) -> QuantConnect.API.BaseLiveAlgorithmSettings:
+        pass
+
+    Account: str
+
+    Environment: QuantConnect.BrokerageEnvironment
+
+    Id: str
+
+    Password: str
+
+    User: str
+
+
+
+class CreatedNode(QuantConnect.Api.RestResponse):
+    """
+    Rest api response wrapper for node/create, reads in the nodes information into a 
+                node object
+    
+    CreatedNode()
+    """
+    Node: QuantConnect.API.Node
+
+
+
+class DefaultLiveAlgorithmSettings(QuantConnect.API.BaseLiveAlgorithmSettings):
+    """
+    Default live algorithm settings
+    
+    DefaultLiveAlgorithmSettings(user: str, password: str, environment: BrokerageEnvironment, account: str)
+    """
+    def __init__(self, user: str, password: str, environment: QuantConnect.BrokerageEnvironment, account: str) -> QuantConnect.API.DefaultLiveAlgorithmSettings:
+        pass
+
+
+class Dividend(System.object):
+    """
+    Dividend returned from the api
+    
+    Dividend()
+    """
+    Date: datetime.datetime
+
+    DividendPerShare: float
+
+    ReferencePrice: float
+
+    Symbol: QuantConnect.Symbol
+
+    SymbolID: str
+
+
+
+class DividendList(QuantConnect.Api.RestResponse):
+    """
+    Collection container for a list of dividend objects
+    
+    DividendList()
+    """
+    Dividends: typing.List[QuantConnect.API.Dividend]
+
+
+
+class FXCMLiveAlgorithmSettings(QuantConnect.API.BaseLiveAlgorithmSettings):
+    """
+    Algorithm setting for trading with FXCM
+    
+    FXCMLiveAlgorithmSettings(user: str, password: str, environment: BrokerageEnvironment, account: str)
+    """
+    def __init__(self, user: str, password: str, environment: QuantConnect.BrokerageEnvironment, account: str) -> QuantConnect.API.FXCMLiveAlgorithmSettings:
+        pass
+
+
+class InteractiveBrokersLiveAlgorithmSettings(QuantConnect.API.BaseLiveAlgorithmSettings):
+    """
+    Live algorithm settings for trading with Interactive Brokers
+    
+    InteractiveBrokersLiveAlgorithmSettings(user: str, password: str, account: str)
+    """
+    def __init__(self, user: str, password: str, account: str) -> QuantConnect.API.InteractiveBrokersLiveAlgorithmSettings:
+        pass
+
+
+class LiveAlgorithm(QuantConnect.Api.RestResponse):
+    """
+    Live algorithm instance result from the QuantConnect Rest API.
+    
+    LiveAlgorithm()
+    """
+    Brokerage: str
+    DeployId: str
+    Error: str
+    Launched: datetime.datetime
+    ProjectId: int
+    Status: QuantConnect.AlgorithmStatus
+    Stopped: typing.Optional[datetime.datetime]
+    Subscription: str
+
+class LiveAlgorithmApiSettingsWrapper(System.object):
+    """
+    Helper class to put BaseLiveAlgorithmSettings in proper format.
+    
+    LiveAlgorithmApiSettingsWrapper(projectId: int, compileId: str, serverType: str, settings: BaseLiveAlgorithmSettings, version: str)
+    """
+    def __init__(self, projectId: int, compileId: str, serverType: str, settings: QuantConnect.API.BaseLiveAlgorithmSettings, version: str) -> QuantConnect.API.LiveAlgorithmApiSettingsWrapper:
+        pass
+
+    Brokerage: QuantConnect.API.BaseLiveAlgorithmSettings
+
+    CompileId: str
+
+    ProjectId: int
+
+    ServerType: str
+
+    VersionId: str
+
+
+
+class LiveAlgorithmResults(QuantConnect.Api.RestResponse):
+    """
+    Details a live algorithm from the "live/read" Api endpoint
+    
+    LiveAlgorithmResults()
+    """
+    LiveResults: QuantConnect.API.LiveResultsData
+
+
+
+class LiveAlgorithmResultsJsonConverter(Newtonsoft.Json.JsonConverter):
+    """
+    Custom JsonConverter for LiveResults data for live algorithms
+    
+    LiveAlgorithmResultsJsonConverter()
+    """
+    def CanConvert(self, objectType: type) -> bool:
+        pass
+
+    @staticmethod
+    def CreateLiveResultsFromJObject(jObject: Newtonsoft.Json.Linq.JObject) -> QuantConnect.API.LiveAlgorithmResults:
+        pass
+
+    def ReadJson(self, reader: Newtonsoft.Json.JsonReader, objectType: type, existingValue: object, serializer: Newtonsoft.Json.JsonSerializer) -> object:
+        pass
+
+    def WriteJson(self, writer: Newtonsoft.Json.JsonWriter, value: object, serializer: Newtonsoft.Json.JsonSerializer) -> None:
+        pass
+
+    CanWrite: bool
+
+
+
+class LiveList(QuantConnect.Api.RestResponse):
+    """
+    List of the live algorithms running which match the requested status
+    
+    LiveList()
+    """
+    Algorithms: typing.List[QuantConnect.API.LiveAlgorithm]
+
+class LiveLog(QuantConnect.Api.RestResponse):
+    """
+    Logs from a live algorithm
+    
+    LiveLog()
+    """
+    Logs: typing.List[str]
+
+
+
+class LiveResultsData(System.object):
+    """
+    Holds information about the state and operation of the live running algorithm
+    
+    LiveResultsData()
+    """
+    Resolution: QuantConnect.Resolution
+
+    Results: QuantConnect.Packets.LiveResult
+
+    Version: int
+
+
+
+class Node(System.object):
+    """
+    Node class built for API endpoints nodes/read and nodes/create.
+                Converts JSON properties from API response into data members for the class.
+                Contains all relevant information on a Node to interact through API endpoints.
+    
+    Node()
+    """
+    Busy: bool
+
+    CpuCount: int
+
+    Description: str
+
+    Id: str
+
+    Name: str
+
+    Prices: QuantConnect.API.NodePrices
+
+    ProjectName: str
+
+    Ram: float
+
+    SKU: str
+
+    Speed: float
+
+    UsedBy: str
+
+
+
+class NodeList(QuantConnect.Api.RestResponse):
+    """
+    Rest api response wrapper for node/read, contains sets of node lists for each
+                target environment. List are composed of QuantConnect.API.Node objects.
+    
+    NodeList()
+    """
+    BacktestNodes: typing.List[QuantConnect.API.Node]
+    LiveNodes: typing.List[QuantConnect.API.Node]
+    ResearchNodes: typing.List[QuantConnect.API.Node]
+
+class NodePrices(System.object):
+    """
+    Class for deserializing node prices from node object
+    
+    NodePrices()
+    """
+    Monthly: int
+
+    Yearly: int
+
+
+
+class NodeType(System.Enum, System.IConvertible, System.IFormattable, System.IComparable):
+    """
+    NodeTypes enum for all possible options of target environments
+                Used in conjuction with SKU class as a NodeType is a required parameter for SKU
+    
+    enum NodeType, values: Backtest (0), Live (2), Research (1)
+    """
+    value__: int
+    Backtest: 'NodeType'
+    Live: 'NodeType'
+    Research: 'NodeType'
+
+
+class OandaLiveAlgorithmSettings(QuantConnect.API.BaseLiveAlgorithmSettings):
+    """
+    Live algorithm settings for trading with Oanda
+    
+    OandaLiveAlgorithmSettings(accessToken: str, environment: BrokerageEnvironment, account: str)
+    """
+    def __init__(self, accessToken: str, environment: QuantConnect.BrokerageEnvironment, account: str) -> QuantConnect.API.OandaLiveAlgorithmSettings:
+        pass
+
+    AccessToken: str
+
+    DateIssued: str
+
+
+
+class Prices(System.object):
+    """
+    Prices rest response wrapper
+    
+    Prices()
+    """
+    Price: float
+
+    Symbol: QuantConnect.Symbol
+
+    SymbolID: str
+
+    Updated: datetime.datetime
+
+
+class PricesList(QuantConnect.Api.RestResponse):
+    """
+    Collection container for a list of prices objects
+    
+    PricesList()
+    """
+    Prices: typing.List[QuantConnect.API.Prices]
+
+class SKU(System.object):
+    """
+    Class for generating a SKU for a node with a given configuration
+                Every SKU is made up of 3 variables: 
+                - Target environment (L for live, B for Backtest, R for Research)
+                - CPU core count
+                - Dedicated RAM (GB)
+    
+    SKU(cores: int, memory: int, target: NodeType)
+    """
+    def ToString(self) -> str:
+        pass
+
+    def __init__(self, cores: int, memory: int, target: QuantConnect.API.NodeType) -> QuantConnect.API.SKU:
+        pass
+
+    Cores: int
+    Memory: int
+    Target: QuantConnect.API.NodeType
+
+class Split(System.object):
+    """
+    Split returned from the api
+    
+    Split()
+    """
+    Date: datetime.datetime
+
+    ReferencePrice: float
+
+    SplitFactor: float
+
+    Symbol: QuantConnect.Symbol
+
+    SymbolID: str
+
+
+
+class SplitList(QuantConnect.Api.RestResponse):
+    """
+    Collection container for a list of split objects
+    
+    SplitList()
+    """
+    Splits: typing.List[QuantConnect.API.Split]
+
+
+
+class TradierLiveAlgorithmSettings(QuantConnect.API.BaseLiveAlgorithmSettings):
+    """
+    Live algorithm settings for trading with Tradier
+    
+    TradierLiveAlgorithmSettings(accessToken: str, dateIssued: str, refreshToken: str, account: str)
+    """
+    def __init__(self, accessToken: str, dateIssued: str, refreshToken: str, account: str) -> QuantConnect.API.TradierLiveAlgorithmSettings:
+        pass
+
+    AccessToken: str
+
+    DateIssued: str
+
+    Lifetime: str
+
+    RefreshToken: str
+
+
+

Algorithm.Python/stubs/QuantConnect/Algorithm/Framework/Alphas/Analysis/Functions.py

@@ -0,0 +1,26 @@
+# encoding: utf-8
+# module QuantConnect.Algorithm.Framework.Alphas.Analysis.Functions calls itself Functions
+# from QuantConnect.Common, Version=2.4.0.0, Culture=neutral, PublicKeyToken=null
+# by generator 1.145
+# no doc
+
+# imports
+import datetime
+import QuantConnect.Algorithm.Framework.Alphas
+import QuantConnect.Algorithm.Framework.Alphas.Analysis
+import typing
+
+# no functions
+# classes
+
+class BinaryInsightScoreFunction(System.object, QuantConnect.Algorithm.Framework.Alphas.Analysis.IInsightScoreFunction):
+    """
+    Defines a scoring function that always returns 1 or 0.
+                You're either right or you're wrong with this one :)
+    
+    BinaryInsightScoreFunction()
+    """
+    def Evaluate(self, context: QuantConnect.Algorithm.Framework.Alphas.Analysis.InsightAnalysisContext, scoreType: QuantConnect.Algorithm.Framework.Alphas.InsightScoreType) -> float:
+        pass
+
+

Algorithm.Python/stubs/QuantConnect/Algorithm/Framework/Alphas/Analysis/Providers.py

@@ -0,0 +1,45 @@
+# encoding: utf-8
+# module QuantConnect.Algorithm.Framework.Alphas.Analysis.Providers calls itself Providers
+# from QuantConnect.Common, Version=2.4.0.0, Culture=neutral, PublicKeyToken=null
+# by generator 1.145
+# no doc
+
+# imports
+import datetime
+import QuantConnect
+import QuantConnect.Algorithm.Framework.Alphas
+import QuantConnect.Algorithm.Framework.Alphas.Analysis
+import QuantConnect.Algorithm.Framework.Alphas.Analysis.Providers
+import QuantConnect.Interfaces
+import typing
+
+# no functions
+# classes
+
+class AlgorithmSecurityValuesProvider(System.object, QuantConnect.Algorithm.Framework.Alphas.Analysis.ISecurityValuesProvider):
+    """
+    Provides an implementation of QuantConnect.Securities.ISecurityProvider that uses the QuantConnect.Securities.SecurityManager
+                to get the price for the specified symbols
+    
+    AlgorithmSecurityValuesProvider(algorithm: IAlgorithm)
+    """
+    def GetAllValues(self) -> QuantConnect.Algorithm.Framework.Alphas.Analysis.ReadOnlySecurityValuesCollection:
+        pass
+
+    def GetValues(self, symbol: QuantConnect.Symbol) -> QuantConnect.Algorithm.Framework.Alphas.Analysis.SecurityValues:
+        pass
+
+    def __init__(self, algorithm: QuantConnect.Interfaces.IAlgorithm) -> QuantConnect.Algorithm.Framework.Alphas.Analysis.Providers.AlgorithmSecurityValuesProvider:
+        pass
+
+
+class DefaultInsightScoreFunctionProvider(System.object, QuantConnect.Algorithm.Framework.Alphas.Analysis.IInsightScoreFunctionProvider):
+    """
+    Default implementation of QuantConnect.Algorithm.Framework.Alphas.Analysis.IInsightScoreFunctionProvider always returns the QuantConnect.Algorithm.Framework.Alphas.Analysis.Functions.BinaryInsightScoreFunction
+    
+    DefaultInsightScoreFunctionProvider()
+    """
+    def GetScoreFunction(self, insightType: QuantConnect.Algorithm.Framework.Alphas.InsightType, scoreType: QuantConnect.Algorithm.Framework.Alphas.InsightScoreType) -> QuantConnect.Algorithm.Framework.Alphas.Analysis.IInsightScoreFunction:
+        pass
+
+

Algorithm.Python/stubs/QuantConnect/Algorithm/Framework/Alphas/Analysis/__init__.py

@@ -0,0 +1,210 @@
+import typing
+import System.Collections.Generic
+import System
+import QuantConnect.Securities
+import QuantConnect.Algorithm.Framework.Alphas.Analysis
+import QuantConnect.Algorithm.Framework.Alphas
+import QuantConnect
+import datetime
+
+# no functions
+# classes
+
+class IInsightManager(System.IDisposable):
+    """ Encapsulates the storage and on-line scoring of insights. """
+    def AddExtension(self, extension: QuantConnect.Algorithm.Framework.Alphas.IInsightManagerExtension) -> None:
+        pass
+
+    def InitializeExtensionsForRange(self, start: datetime.datetime, end: datetime.datetime, current: datetime.datetime) -> None:
+        pass
+
+    def RemoveInsights(self, insightIds: typing.List[System.Guid]) -> None:
+        pass
+
+    def Step(self, frontierTimeUtc: datetime.datetime, securityValuesCollection: QuantConnect.Algorithm.Framework.Alphas.Analysis.ReadOnlySecurityValuesCollection, generatedInsights: QuantConnect.Algorithm.Framework.Alphas.GeneratedInsightsCollection) -> None:
+        pass
+
+    AllInsights: typing.List[QuantConnect.Algorithm.Framework.Alphas.Insight]
+
+    ClosedInsights: typing.List[QuantConnect.Algorithm.Framework.Alphas.Insight]
+
+    OpenInsights: typing.List[QuantConnect.Algorithm.Framework.Alphas.Insight]
+
+
+
+class IInsightScoreFunction:
+    """
+    Defines a function used to determine how correct a particular insight is.
+                The result of calling QuantConnect.Algorithm.Framework.Alphas.Analysis.IInsightScoreFunction.Evaluate(QuantConnect.Algorithm.Framework.Alphas.Analysis.InsightAnalysisContext,QuantConnect.Algorithm.Framework.Alphas.InsightScoreType) is expected to be within the range [0, 1]
+                where 0 is completely wrong and 1 is completely right
+    """
+    def Evaluate(self, context: QuantConnect.Algorithm.Framework.Alphas.Analysis.InsightAnalysisContext, scoreType: QuantConnect.Algorithm.Framework.Alphas.InsightScoreType) -> float:
+        pass
+
+
+class IInsightScoreFunctionProvider:
+    """ Retrieves the registered scoring function for the specified insight/score type """
+    def GetScoreFunction(self, insightType: QuantConnect.Algorithm.Framework.Alphas.InsightType, scoreType: QuantConnect.Algorithm.Framework.Alphas.InsightScoreType) -> QuantConnect.Algorithm.Framework.Alphas.Analysis.IInsightScoreFunction:
+        pass
+
+
+class InsightAnalysisContext(System.object):
+    """
+    Defines a context for performing analysis on a single insight
+    
+    InsightAnalysisContext(insight: Insight, initialValues: SecurityValues, analysisPeriod: TimeSpan)
+    """
+    def Equals(self, obj: object) -> bool:
+        pass
+
+    def Get(self, key: str) -> QuantConnect.Algorithm.Framework.Alphas.Analysis.T:
+        pass
+
+    def GetHashCode(self) -> int:
+        pass
+
+    def Set(self, key: str, value: object) -> None:
+        pass
+
+    def ShouldAnalyze(self, scoreType: QuantConnect.Algorithm.Framework.Alphas.InsightScoreType) -> bool:
+        pass
+
+    def ToString(self) -> str:
+        pass
+
+    def __init__(self, insight: QuantConnect.Algorithm.Framework.Alphas.Insight, initialValues: QuantConnect.Algorithm.Framework.Alphas.Analysis.SecurityValues, analysisPeriod: datetime.timedelta) -> QuantConnect.Algorithm.Framework.Alphas.Analysis.InsightAnalysisContext:
+        pass
+
+    AnalysisEndTimeUtc: datetime.datetime
+
+    CurrentValues: QuantConnect.Algorithm.Framework.Alphas.Analysis.SecurityValues
+
+    Id: System.Guid
+
+    InitialValues: QuantConnect.Algorithm.Framework.Alphas.Analysis.SecurityValues
+
+    Insight: QuantConnect.Algorithm.Framework.Alphas.Insight
+
+    InsightPeriodClosed: bool
+
+    NormalizedTime: float
+
+    NormalizedTimeStep: float
+
+    Score: QuantConnect.Algorithm.Framework.Alphas.InsightScore
+
+    Symbol: QuantConnect.Symbol
+
+
+
+class InsightManager(System.object, System.IDisposable, QuantConnect.Algorithm.Framework.Alphas.Analysis.IInsightManager):
+    """
+    Encapsulates the storage and on-line scoring of insights.
+    
+    InsightManager(scoreFunctionProvider: IInsightScoreFunctionProvider, extraAnalysisPeriodRatio: float, *extensions: Array[IInsightManagerExtension])
+    """
+    def AddExtension(self, extension: QuantConnect.Algorithm.Framework.Alphas.IInsightManagerExtension) -> None:
+        pass
+
+    def ContextsOpenAt(self, frontierTimeUtc: datetime.datetime) -> typing.List[QuantConnect.Algorithm.Framework.Alphas.Analysis.InsightAnalysisContext]:
+        pass
+
+    def Dispose(self) -> None:
+        pass
+
+    def GetUpdatedContexts(self) -> typing.List[QuantConnect.Algorithm.Framework.Alphas.Analysis.InsightAnalysisContext]:
+        pass
+
+    def InitializeExtensionsForRange(self, start: datetime.datetime, end: datetime.datetime, current: datetime.datetime) -> None:
+        pass
+
+    def RemoveInsights(self, insightIds: typing.List[System.Guid]) -> None:
+        pass
+
+    def Step(self, frontierTimeUtc: datetime.datetime, securityValuesCollection: QuantConnect.Algorithm.Framework.Alphas.Analysis.ReadOnlySecurityValuesCollection, generatedInsights: QuantConnect.Algorithm.Framework.Alphas.GeneratedInsightsCollection) -> None:
+        pass
+
+    def __init__(self, scoreFunctionProvider: QuantConnect.Algorithm.Framework.Alphas.Analysis.IInsightScoreFunctionProvider, extraAnalysisPeriodRatio: float, extensions: typing.List[QuantConnect.Algorithm.Framework.Alphas.IInsightManagerExtension]) -> QuantConnect.Algorithm.Framework.Alphas.Analysis.InsightManager:
+        pass
+
+    AllInsights: typing.List[QuantConnect.Algorithm.Framework.Alphas.Insight]
+
+    ClosedInsights: typing.List[QuantConnect.Algorithm.Framework.Alphas.Insight]
+
+    OpenInsights: typing.List[QuantConnect.Algorithm.Framework.Alphas.Insight]
+
+
+    ScoreTypes: Array[InsightScoreType]
+
+
+class ISecurityValuesProvider:
+    """
+    Provides a simple abstraction that returns a security's current price and volatility.
+                This facilitates testing by removing the dependency of IAlgorithm on the analysis components
+    """
+    def GetAllValues(self) -> QuantConnect.Algorithm.Framework.Alphas.Analysis.ReadOnlySecurityValuesCollection:
+        pass
+
+    def GetValues(self, symbol: QuantConnect.Symbol) -> QuantConnect.Algorithm.Framework.Alphas.Analysis.SecurityValues:
+        pass
+
+
+class ReadOnlySecurityValuesCollection(System.object):
+    """
+    Defines the security values at a given instant. This is analagous
+                to TimeSlice/Slice, but decoupled from the algorithm thread and is
+                intended to contain all of the information necessary to score all
+                insight at this particular time step
+    
+    ReadOnlySecurityValuesCollection(securityValuesBySymbol: Dictionary[Symbol, SecurityValues])
+    ReadOnlySecurityValuesCollection(securityValuesBySymbolFunc: Func[Symbol, SecurityValues])
+    """
+    @typing.overload
+    def __init__(self, securityValuesBySymbol: System.Collections.Generic.Dictionary[QuantConnect.Symbol, QuantConnect.Algorithm.Framework.Alphas.Analysis.SecurityValues]) -> QuantConnect.Algorithm.Framework.Alphas.Analysis.ReadOnlySecurityValuesCollection:
+        pass
+
+    @typing.overload
+    def __init__(self, securityValuesBySymbolFunc: typing.Callable[[QuantConnect.Symbol], QuantConnect.Algorithm.Framework.Alphas.Analysis.SecurityValues]) -> QuantConnect.Algorithm.Framework.Alphas.Analysis.ReadOnlySecurityValuesCollection:
+        pass
+
+    def __init__(self, *args) -> QuantConnect.Algorithm.Framework.Alphas.Analysis.ReadOnlySecurityValuesCollection:
+        pass
+
+    Item: indexer#
+
+
+class SecurityValues(System.object):
+    """
+    Contains security values required by insight analysis components
+    
+    SecurityValues(symbol: Symbol, timeUtc: DateTime, exchangeHours: SecurityExchangeHours, price: Decimal, volatility: Decimal, volume: Decimal, quoteCurrencyConversionRate: Decimal)
+    """
+    def Get(self, type: QuantConnect.Algorithm.Framework.Alphas.InsightType) -> float:
+        pass
+
+    def __init__(self, symbol: QuantConnect.Symbol, timeUtc: datetime.datetime, exchangeHours: QuantConnect.Securities.SecurityExchangeHours, price: float, volatility: float, volume: float, quoteCurrencyConversionRate: float) -> QuantConnect.Algorithm.Framework.Alphas.Analysis.SecurityValues:
+        pass
+
+    ExchangeHours: QuantConnect.Securities.SecurityExchangeHours
+
+    Price: float
+
+    QuoteCurrencyConversionRate: float
+
+    Symbol: QuantConnect.Symbol
+
+    TimeUtc: datetime.datetime
+
+    Volatility: float
+
+    Volume: float
+
+
+
+class SecurityValuesProviderExtensions(System.object):
+    """ Provides extension methods for QuantConnect.Algorithm.Framework.Alphas.Analysis.ISecurityValuesProvider """
+    @staticmethod
+    def GetValues(securityValuesProvider: QuantConnect.Algorithm.Framework.Alphas.Analysis.ISecurityValuesProvider, symbols: typing.List[QuantConnect.Symbol]) -> QuantConnect.Algorithm.Framework.Alphas.Analysis.ReadOnlySecurityValuesCollection:
+        pass
+
+    __all__: list

Algorithm.Python/stubs/QuantConnect/Algorithm/Framework/Alphas/Serialization.py

@@ -0,0 +1,85 @@
+# encoding: utf-8
+# module QuantConnect.Algorithm.Framework.Alphas.Serialization calls itself Serialization
+# from QuantConnect.Common, Version=2.4.0.0, Culture=neutral, PublicKeyToken=null
+# by generator 1.145
+# no doc
+
+# imports
+import datetime
+import QuantConnect.Algorithm.Framework.Alphas
+import QuantConnect.Algorithm.Framework.Alphas.Serialization
+import typing
+
+# no functions
+# classes
+
+class InsightJsonConverter(QuantConnect.Util.TypeChangeJsonConverter[Insight, SerializedInsight]):
+    """
+    Defines how insights should be serialized to json
+    
+    InsightJsonConverter()
+    """
+
+
+class SerializedInsight(System.object):
+    """
+    DTO used for serializing an insight that was just generated by an algorithm.
+                This type does not contain any of the analysis dependent fields, such as scores
+                and estimated value
+    
+    SerializedInsight()
+    SerializedInsight(insight: Insight)
+    """
+    @typing.overload
+    def __init__(self) -> QuantConnect.Algorithm.Framework.Alphas.Serialization.SerializedInsight:
+        pass
+
+    @typing.overload
+    def __init__(self, insight: QuantConnect.Algorithm.Framework.Alphas.Insight) -> QuantConnect.Algorithm.Framework.Alphas.Serialization.SerializedInsight:
+        pass
+
+    def __init__(self, *args) -> QuantConnect.Algorithm.Framework.Alphas.Serialization.SerializedInsight:
+        pass
+
+    CloseTime: float
+
+    Confidence: typing.Optional[float]
+
+    CreatedTime: float
+
+    Direction: QuantConnect.Algorithm.Framework.Alphas.InsightDirection
+
+    EstimatedValue: float
+
+    GeneratedTime: float
+
+    GroupId: str
+
+    Id: str
+
+    Magnitude: typing.Optional[float]
+
+    Period: float
+
+    ReferenceValue: float
+
+    ReferenceValueFinal: float
+
+    ScoreDirection: float
+
+    ScoreIsFinal: bool
+
+    ScoreMagnitude: float
+
+    SourceModel: str
+
+    Symbol: str
+
+    Ticker: str
+
+    Type: QuantConnect.Algorithm.Framework.Alphas.InsightType
+
+    Weight: typing.Optional[float]
+
+
+

Algorithm.Python/stubs/QuantConnect/Algorithm/Framework/Alphas/____init___1.py

@@ -0,0 +1,272 @@
+from .____init___2 import *
+import typing
+import System.Collections.Generic
+import System
+import QuantConnect.Securities
+import QuantConnect.Indicators
+import QuantConnect.Data.UniverseSelection
+import QuantConnect.Data
+import QuantConnect.Algorithm.Framework.Alphas.Serialization
+import QuantConnect.Algorithm.Framework.Alphas.Analysis
+import QuantConnect.Algorithm.Framework.Alphas
+import QuantConnect.Algorithm
+import QuantConnect
+import Python.Runtime
+import datetime
+
+
+class INamedModel:
+    """
+    Provides a marker interface allowing models to define their own names.
+                If not specified, the framework will use the model's type name.
+                Implementation of this is not required unless you plan on running multiple models
+                of the same type w/ different parameters.
+    """
+    Name: str
+
+
+
+class Insight(System.object):
+    """
+    Defines a alpha prediction for a single symbol generated by the algorithm
+    
+    Insight(symbol: Symbol, period: TimeSpan, type: InsightType, direction: InsightDirection)
+    Insight(symbol: Symbol, period: TimeSpan, type: InsightType, direction: InsightDirection, magnitude: Nullable[float], confidence: Nullable[float], sourceModel: str, weight: Nullable[float])
+    Insight(symbol: Symbol, expiryFunc: Func[DateTime, DateTime], type: InsightType, direction: InsightDirection)
+    Insight(symbol: Symbol, expiryFunc: Func[DateTime, DateTime], type: InsightType, direction: InsightDirection, magnitude: Nullable[float], confidence: Nullable[float], sourceModel: str, weight: Nullable[float])
+    Insight(generatedTimeUtc: DateTime, symbol: Symbol, period: TimeSpan, type: InsightType, direction: InsightDirection, magnitude: Nullable[float], confidence: Nullable[float], sourceModel: str, weight: Nullable[float])
+    """
+    def Clone(self) -> QuantConnect.Algorithm.Framework.Alphas.Insight:
+        pass
+
+    @staticmethod
+    @typing.overload
+    def ComputeCloseTime(exchangeHours: QuantConnect.Securities.SecurityExchangeHours, generatedTimeUtc: datetime.datetime, resolution: QuantConnect.Resolution, barCount: int) -> datetime.datetime:
+        pass
+
+    @staticmethod
+    @typing.overload
+    def ComputeCloseTime(exchangeHours: QuantConnect.Securities.SecurityExchangeHours, generatedTimeUtc: datetime.datetime, period: datetime.timedelta) -> datetime.datetime:
+        pass
+
+    def ComputeCloseTime(self, *args) -> datetime.datetime:
+        pass
+
+    @staticmethod
+    def ComputePeriod(exchangeHours: QuantConnect.Securities.SecurityExchangeHours, generatedTimeUtc: datetime.datetime, closeTimeUtc: datetime.datetime) -> datetime.timedelta:
+        pass
+
+    @staticmethod
+    def FromSerializedInsight(serializedInsight: QuantConnect.Algorithm.Framework.Alphas.Serialization.SerializedInsight) -> QuantConnect.Algorithm.Framework.Alphas.Insight:
+        pass
+
+    @staticmethod
+    @typing.overload
+    def Group(insights: typing.List[QuantConnect.Algorithm.Framework.Alphas.Insight]) -> typing.List[QuantConnect.Algorithm.Framework.Alphas.Insight]:
+        pass
+
+    @staticmethod
+    @typing.overload
+    def Group(insight: QuantConnect.Algorithm.Framework.Alphas.Insight) -> typing.List[QuantConnect.Algorithm.Framework.Alphas.Insight]:
+        pass
+
+    def Group(self, *args) -> typing.List[QuantConnect.Algorithm.Framework.Alphas.Insight]:
+        pass
+
+    def IsActive(self, utcTime: datetime.datetime) -> bool:
+        pass
+
+    def IsExpired(self, utcTime: datetime.datetime) -> bool:
+        pass
+
+    @staticmethod
+    @typing.overload
+    def Price(symbol: QuantConnect.Symbol, resolution: QuantConnect.Resolution, barCount: int, direction: QuantConnect.Algorithm.Framework.Alphas.InsightDirection, magnitude: typing.Optional[float], confidence: typing.Optional[float], sourceModel: str, weight: typing.Optional[float]) -> QuantConnect.Algorithm.Framework.Alphas.Insight:
+        pass
+
+    @staticmethod
+    @typing.overload
+    def Price(symbol: QuantConnect.Symbol, closeTimeLocal: datetime.datetime, direction: QuantConnect.Algorithm.Framework.Alphas.InsightDirection, magnitude: typing.Optional[float], confidence: typing.Optional[float], sourceModel: str, weight: typing.Optional[float]) -> QuantConnect.Algorithm.Framework.Alphas.Insight:
+        pass
+
+    @staticmethod
+    @typing.overload
+    def Price(symbol: QuantConnect.Symbol, period: datetime.timedelta, direction: QuantConnect.Algorithm.Framework.Alphas.InsightDirection, magnitude: typing.Optional[float], confidence: typing.Optional[float], sourceModel: str, weight: typing.Optional[float]) -> QuantConnect.Algorithm.Framework.Alphas.Insight:
+        pass
+
+    @staticmethod
+    @typing.overload
+    def Price(symbol: QuantConnect.Symbol, expiryFunc: typing.Callable[[datetime.datetime], datetime.datetime], direction: QuantConnect.Algorithm.Framework.Alphas.InsightDirection, magnitude: typing.Optional[float], confidence: typing.Optional[float], sourceModel: str, weight: typing.Optional[float]) -> QuantConnect.Algorithm.Framework.Alphas.Insight:
+        pass
+
+    def Price(self, *args) -> QuantConnect.Algorithm.Framework.Alphas.Insight:
+        pass
+
+    def SetPeriodAndCloseTime(self, exchangeHours: QuantConnect.Securities.SecurityExchangeHours) -> None:
+        pass
+
+    def ToString(self) -> str:
+        pass
+
+    @typing.overload
+    def __init__(self, symbol: QuantConnect.Symbol, period: datetime.timedelta, type: QuantConnect.Algorithm.Framework.Alphas.InsightType, direction: QuantConnect.Algorithm.Framework.Alphas.InsightDirection) -> QuantConnect.Algorithm.Framework.Alphas.Insight:
+        pass
+
+    @typing.overload
+    def __init__(self, symbol: QuantConnect.Symbol, period: datetime.timedelta, type: QuantConnect.Algorithm.Framework.Alphas.InsightType, direction: QuantConnect.Algorithm.Framework.Alphas.InsightDirection, magnitude: typing.Optional[float], confidence: typing.Optional[float], sourceModel: str, weight: typing.Optional[float]) -> QuantConnect.Algorithm.Framework.Alphas.Insight:
+        pass
+
+    @typing.overload
+    def __init__(self, symbol: QuantConnect.Symbol, expiryFunc: typing.Callable[[datetime.datetime], datetime.datetime], type: QuantConnect.Algorithm.Framework.Alphas.InsightType, direction: QuantConnect.Algorithm.Framework.Alphas.InsightDirection) -> QuantConnect.Algorithm.Framework.Alphas.Insight:
+        pass
+
+    @typing.overload
+    def __init__(self, symbol: QuantConnect.Symbol, expiryFunc: typing.Callable[[datetime.datetime], datetime.datetime], type: QuantConnect.Algorithm.Framework.Alphas.InsightType, direction: QuantConnect.Algorithm.Framework.Alphas.InsightDirection, magnitude: typing.Optional[float], confidence: typing.Optional[float], sourceModel: str, weight: typing.Optional[float]) -> QuantConnect.Algorithm.Framework.Alphas.Insight:
+        pass
+
+    @typing.overload
+    def __init__(self, generatedTimeUtc: datetime.datetime, symbol: QuantConnect.Symbol, period: datetime.timedelta, type: QuantConnect.Algorithm.Framework.Alphas.InsightType, direction: QuantConnect.Algorithm.Framework.Alphas.InsightDirection, magnitude: typing.Optional[float], confidence: typing.Optional[float], sourceModel: str, weight: typing.Optional[float]) -> QuantConnect.Algorithm.Framework.Alphas.Insight:
+        pass
+
+    def __init__(self, *args) -> QuantConnect.Algorithm.Framework.Alphas.Insight:
+        pass
+
+    CloseTimeUtc: datetime.datetime
+
+    Confidence: typing.Optional[float]
+
+    Direction: QuantConnect.Algorithm.Framework.Alphas.InsightDirection
+
+    EstimatedValue: float
+
+    GeneratedTimeUtc: datetime.datetime
+
+    GroupId: typing.Optional[System.Guid]
+
+    Id: System.Guid
+
+    Magnitude: typing.Optional[float]
+
+    Period: datetime.timedelta
+
+    ReferenceValue: float
+
+    ReferenceValueFinal: float
+
+    Score: QuantConnect.Algorithm.Framework.Alphas.InsightScore
+
+    SourceModel: str
+
+    Symbol: QuantConnect.Symbol
+
+    Type: QuantConnect.Algorithm.Framework.Alphas.InsightType
+
+    Weight: typing.Optional[float]
+
+
+
+class InsightCollection(System.object, System.Collections.IEnumerable, System.Collections.Generic.ICollection[Insight], System.Collections.Generic.IEnumerable[Insight]):
+    """
+    Provides a collection for managing insights. This type provides collection access semantics
+                as well as dictionary access semantics through TryGetValue, ContainsKey, and this[symbol]
+    
+    InsightCollection()
+    """
+    def Add(self, item: QuantConnect.Algorithm.Framework.Alphas.Insight) -> None:
+        pass
+
+    def AddRange(self, insights: typing.List[QuantConnect.Algorithm.Framework.Alphas.Insight]) -> None:
+        pass
+
+    @typing.overload
+    def Clear(self) -> None:
+        pass
+
+    @typing.overload
+    def Clear(self, symbols: typing.List[QuantConnect.Symbol]) -> None:
+        pass
+
+    def Clear(self, *args) -> None:
+        pass
+
+    def Contains(self, item: QuantConnect.Algorithm.Framework.Alphas.Insight) -> bool:
+        pass
+
+    def ContainsKey(self, symbol: QuantConnect.Symbol) -> bool:
+        pass
+
+    def CopyTo(self, array: typing.List[QuantConnect.Algorithm.Framework.Alphas.Insight], arrayIndex: int) -> None:
+        pass
+
+    def GetActiveInsights(self, utcTime: datetime.datetime) -> typing.List[QuantConnect.Algorithm.Framework.Alphas.Insight]:
+        pass
+
+    def GetEnumerator(self) -> System.Collections.Generic.IEnumerator[QuantConnect.Algorithm.Framework.Alphas.Insight]:
+        pass
+
+    def GetNextExpiryTime(self) -> typing.Optional[datetime.datetime]:
+        pass
+
+    def HasActiveInsights(self, symbol: QuantConnect.Symbol, utcTime: datetime.datetime) -> bool:
+        pass
+
+    def Remove(self, item: QuantConnect.Algorithm.Framework.Alphas.Insight) -> bool:
+        pass
+
+    def RemoveExpiredInsights(self, utcTime: datetime.datetime) -> typing.List[QuantConnect.Algorithm.Framework.Alphas.Insight]:
+        pass
+
+    def TryGetValue(self, symbol: QuantConnect.Symbol, insights: typing.List) -> bool:
+        pass
+
+    Count: int
+
+    IsReadOnly: bool
+
+
+    Item: indexer#
+
+
+class InsightDirection(System.Enum, System.IConvertible, System.IFormattable, System.IComparable):
+    """
+    Specifies the predicted direction for a insight (price/volatility)
+    
+    enum InsightDirection, values: Down (-1), Flat (0), Up (1)
+    """
+    value__: int
+    Down: 'InsightDirection'
+    Flat: 'InsightDirection'
+    Up: 'InsightDirection'
+
+
+class InsightScore(System.object):
+    """
+    Defines the scores given to a particular insight
+    
+    InsightScore()
+    InsightScore(direction: float, magnitude: float, updatedTimeUtc: DateTime)
+    """
+    def GetScore(self, type: QuantConnect.Algorithm.Framework.Alphas.InsightScoreType) -> float:
+        pass
+
+    def ToString(self) -> str:
+        pass
+
+    @typing.overload
+    def __init__(self) -> QuantConnect.Algorithm.Framework.Alphas.InsightScore:
+        pass
+
+    @typing.overload
+    def __init__(self, direction: float, magnitude: float, updatedTimeUtc: datetime.datetime) -> QuantConnect.Algorithm.Framework.Alphas.InsightScore:
+        pass
+
+    def __init__(self, *args) -> QuantConnect.Algorithm.Framework.Alphas.InsightScore:
+        pass
+
+    Direction: float
+
+    IsFinalScore: bool
+
+    Magnitude: float
+
+    UpdatedTimeUtc: datetime.datetime

Algorithm.Python/stubs/QuantConnect/Algorithm/Framework/Alphas/____init___2.py

@@ -0,0 +1,100 @@
+import typing
+import System.Collections.Generic
+import System
+import QuantConnect.Securities
+import QuantConnect.Indicators
+import QuantConnect.Data.UniverseSelection
+import QuantConnect.Data
+import QuantConnect.Algorithm.Framework.Alphas.Serialization
+import QuantConnect.Algorithm.Framework.Alphas.Analysis
+import QuantConnect.Algorithm.Framework.Alphas
+import QuantConnect.Algorithm
+import QuantConnect
+import Python.Runtime
+import datetime
+
+
+
+class InsightScoreType(System.Enum, System.IConvertible, System.IFormattable, System.IComparable):
+    """
+    Defines a specific type of score for a insight
+    
+    enum InsightScoreType, values: Direction (0), Magnitude (1)
+    """
+    value__: int
+    Direction: 'InsightScoreType'
+    Magnitude: 'InsightScoreType'
+
+
+class InsightType(System.Enum, System.IConvertible, System.IFormattable, System.IComparable):
+    """
+    Specifies the type of insight
+    
+    enum InsightType, values: Price (0), Volatility (1)
+    """
+    value__: int
+    Price: 'InsightType'
+    Volatility: 'InsightType'
+
+
+class MacdAlphaModel(QuantConnect.Algorithm.Framework.Alphas.AlphaModel, QuantConnect.Algorithm.Framework.INotifiedSecurityChanges, QuantConnect.Algorithm.Framework.Alphas.IAlphaModel, QuantConnect.Algorithm.Framework.Alphas.INamedModel):
+    """
+    Defines a custom alpha model that uses MACD crossovers. The MACD signal line is
+                used to generate up/down insights if it's stronger than the bounce threshold.
+                If the MACD signal is within the bounce threshold then a flat price insight is returned.
+    
+    MacdAlphaModel(fastPeriod: int, slowPeriod: int, signalPeriod: int, movingAverageType: MovingAverageType, resolution: Resolution)
+    """
+    def OnSecuritiesChanged(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, changes: QuantConnect.Data.UniverseSelection.SecurityChanges) -> None:
+        pass
+
+    def Update(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, data: QuantConnect.Data.Slice) -> typing.List[QuantConnect.Algorithm.Framework.Alphas.Insight]:
+        pass
+
+    def __init__(self, fastPeriod: int, slowPeriod: int, signalPeriod: int, movingAverageType: QuantConnect.Indicators.MovingAverageType, resolution: QuantConnect.Resolution) -> QuantConnect.Algorithm.Framework.Alphas.MacdAlphaModel:
+        pass
+
+
+class NullAlphaModel(QuantConnect.Algorithm.Framework.Alphas.AlphaModel, QuantConnect.Algorithm.Framework.INotifiedSecurityChanges, QuantConnect.Algorithm.Framework.Alphas.IAlphaModel, QuantConnect.Algorithm.Framework.Alphas.INamedModel):
+    """
+    Provides a null implementation of an alpha model
+    
+    NullAlphaModel()
+    """
+    def Update(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, data: QuantConnect.Data.Slice) -> typing.List[QuantConnect.Algorithm.Framework.Alphas.Insight]:
+        pass
+
+
+class PearsonCorrelationPairsTradingAlphaModel(QuantConnect.Algorithm.Framework.Alphas.BasePairsTradingAlphaModel, QuantConnect.Algorithm.Framework.INotifiedSecurityChanges, QuantConnect.Algorithm.Framework.Alphas.IAlphaModel, QuantConnect.Algorithm.Framework.Alphas.INamedModel):
+    """
+    This alpha model is designed to rank every pair combination by its pearson correlation
+                and trade the pair with the hightest correlation
+                This model generates alternating long ratio/short ratio insights emitted as a group
+    
+    PearsonCorrelationPairsTradingAlphaModel(lookback: int, resolution: Resolution, threshold: Decimal, minimumCorrelation: float)
+    """
+    def HasPassedTest(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, asset1: QuantConnect.Symbol, asset2: QuantConnect.Symbol) -> bool:
+        pass
+
+    def OnSecuritiesChanged(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, changes: QuantConnect.Data.UniverseSelection.SecurityChanges) -> None:
+        pass
+
+    def __init__(self, lookback: int, resolution: QuantConnect.Resolution, threshold: float, minimumCorrelation: float) -> QuantConnect.Algorithm.Framework.Alphas.PearsonCorrelationPairsTradingAlphaModel:
+        pass
+
+
+class RsiAlphaModel(QuantConnect.Algorithm.Framework.Alphas.AlphaModel, QuantConnect.Algorithm.Framework.INotifiedSecurityChanges, QuantConnect.Algorithm.Framework.Alphas.IAlphaModel, QuantConnect.Algorithm.Framework.Alphas.INamedModel):
+    """
+    Uses Wilder's RSI to create insights. Using default settings, a cross over below 30 or above 70 will
+                trigger a new insight.
+    
+    RsiAlphaModel(period: int, resolution: Resolution)
+    """
+    def OnSecuritiesChanged(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, changes: QuantConnect.Data.UniverseSelection.SecurityChanges) -> None:
+        pass
+
+    def Update(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, data: QuantConnect.Data.Slice) -> typing.List[QuantConnect.Algorithm.Framework.Alphas.Insight]:
+        pass
+
+    def __init__(self, period: int, resolution: QuantConnect.Resolution) -> QuantConnect.Algorithm.Framework.Alphas.RsiAlphaModel:
+        pass

Algorithm.Python/stubs/QuantConnect/Algorithm/Framework/Alphas/__init__.py

@@ -0,0 +1,226 @@
+from .____init___1 import *
+import typing
+import System.Collections.Generic
+import System
+import QuantConnect.Securities
+import QuantConnect.Indicators
+import QuantConnect.Data.UniverseSelection
+import QuantConnect.Data
+import QuantConnect.Algorithm.Framework.Alphas.Serialization
+import QuantConnect.Algorithm.Framework.Alphas.Analysis
+import QuantConnect.Algorithm.Framework.Alphas
+import QuantConnect.Algorithm
+import QuantConnect
+import Python.Runtime
+import datetime
+
+# no functions
+# classes
+
+class AlphaModel(System.object, QuantConnect.Algorithm.Framework.INotifiedSecurityChanges, QuantConnect.Algorithm.Framework.Alphas.IAlphaModel, QuantConnect.Algorithm.Framework.Alphas.INamedModel):
+    """
+    Provides a base class for alpha models.
+    
+    AlphaModel()
+    """
+    def OnSecuritiesChanged(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, changes: QuantConnect.Data.UniverseSelection.SecurityChanges) -> None:
+        pass
+
+    def Update(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, data: QuantConnect.Data.Slice) -> typing.List[QuantConnect.Algorithm.Framework.Alphas.Insight]:
+        pass
+
+    Name: str
+
+
+
+class AlphaModelExtensions(System.object):
+    """ Provides extension methods for alpha models """
+    @staticmethod
+    def GetModelName(model: QuantConnect.Algorithm.Framework.Alphas.IAlphaModel) -> str:
+        pass
+
+    __all__: list
+
+
+class AlphaModelPythonWrapper(QuantConnect.Algorithm.Framework.Alphas.AlphaModel, QuantConnect.Algorithm.Framework.INotifiedSecurityChanges, QuantConnect.Algorithm.Framework.Alphas.IAlphaModel, QuantConnect.Algorithm.Framework.Alphas.INamedModel):
+    """
+    Provides an implementation of QuantConnect.Algorithm.Framework.Alphas.IAlphaModel that wraps a Python.Runtime.PyObject object
+    
+    AlphaModelPythonWrapper(model: PyObject)
+    """
+    def OnSecuritiesChanged(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, changes: QuantConnect.Data.UniverseSelection.SecurityChanges) -> None:
+        pass
+
+    def Update(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, data: QuantConnect.Data.Slice) -> typing.List[QuantConnect.Algorithm.Framework.Alphas.Insight]:
+        pass
+
+    def __init__(self, model: Python.Runtime.PyObject) -> QuantConnect.Algorithm.Framework.Alphas.AlphaModelPythonWrapper:
+        pass
+
+    Name: str
+
+
+
+class BasePairsTradingAlphaModel(QuantConnect.Algorithm.Framework.Alphas.AlphaModel, QuantConnect.Algorithm.Framework.INotifiedSecurityChanges, QuantConnect.Algorithm.Framework.Alphas.IAlphaModel, QuantConnect.Algorithm.Framework.Alphas.INamedModel):
+    """
+    This alpha model is designed to accept every possible pair combination
+                from securities selected by the universe selection model
+                This model generates alternating long ratio/short ratio insights emitted as a group
+    
+    BasePairsTradingAlphaModel(lookback: int, resolution: Resolution, threshold: Decimal)
+    """
+    def HasPassedTest(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, asset1: QuantConnect.Symbol, asset2: QuantConnect.Symbol) -> bool:
+        pass
+
+    def OnSecuritiesChanged(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, changes: QuantConnect.Data.UniverseSelection.SecurityChanges) -> None:
+        pass
+
+    def Update(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, data: QuantConnect.Data.Slice) -> typing.List[QuantConnect.Algorithm.Framework.Alphas.Insight]:
+        pass
+
+    def __init__(self, lookback: int, resolution: QuantConnect.Resolution, threshold: float) -> QuantConnect.Algorithm.Framework.Alphas.BasePairsTradingAlphaModel:
+        pass
+
+    Securities: System.Collections.Generic.HashSet[QuantConnect.Securities.Security]
+
+
+
+class CompositeAlphaModel(QuantConnect.Algorithm.Framework.Alphas.AlphaModel, QuantConnect.Algorithm.Framework.INotifiedSecurityChanges, QuantConnect.Algorithm.Framework.Alphas.IAlphaModel, QuantConnect.Algorithm.Framework.Alphas.INamedModel):
+    """
+    Provides an implementation of QuantConnect.Algorithm.Framework.Alphas.IAlphaModel that combines multiple alpha
+                models into a single alpha model and properly sets each insights 'SourceModel' property.
+    
+    CompositeAlphaModel(*alphaModels: Array[IAlphaModel])
+    CompositeAlphaModel(*alphaModels: Array[PyObject])
+    CompositeAlphaModel(alphaModel: PyObject)
+    """
+    @typing.overload
+    def AddAlpha(self, alphaModel: QuantConnect.Algorithm.Framework.Alphas.IAlphaModel) -> None:
+        pass
+
+    @typing.overload
+    def AddAlpha(self, pyAlphaModel: Python.Runtime.PyObject) -> None:
+        pass
+
+    def AddAlpha(self, *args) -> None:
+        pass
+
+    def OnSecuritiesChanged(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, changes: QuantConnect.Data.UniverseSelection.SecurityChanges) -> None:
+        pass
+
+    def Update(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, data: QuantConnect.Data.Slice) -> typing.List[QuantConnect.Algorithm.Framework.Alphas.Insight]:
+        pass
+
+    @typing.overload
+    def __init__(self, alphaModels: typing.List[QuantConnect.Algorithm.Framework.Alphas.IAlphaModel]) -> QuantConnect.Algorithm.Framework.Alphas.CompositeAlphaModel:
+        pass
+
+    @typing.overload
+    def __init__(self, alphaModels: typing.List[Python.Runtime.PyObject]) -> QuantConnect.Algorithm.Framework.Alphas.CompositeAlphaModel:
+        pass
+
+    @typing.overload
+    def __init__(self, alphaModel: Python.Runtime.PyObject) -> QuantConnect.Algorithm.Framework.Alphas.CompositeAlphaModel:
+        pass
+
+    def __init__(self, *args) -> QuantConnect.Algorithm.Framework.Alphas.CompositeAlphaModel:
+        pass
+
+
+class ConstantAlphaModel(QuantConnect.Algorithm.Framework.Alphas.AlphaModel, QuantConnect.Algorithm.Framework.INotifiedSecurityChanges, QuantConnect.Algorithm.Framework.Alphas.IAlphaModel, QuantConnect.Algorithm.Framework.Alphas.INamedModel):
+    """
+    Provides an implementation of QuantConnect.Algorithm.Framework.Alphas.IAlphaModel that always returns the same insight for each security
+    
+    ConstantAlphaModel(type: InsightType, direction: InsightDirection, period: TimeSpan)
+    ConstantAlphaModel(type: InsightType, direction: InsightDirection, period: TimeSpan, magnitude: Nullable[float], confidence: Nullable[float], weight: Nullable[float])
+    """
+    def OnSecuritiesChanged(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, changes: QuantConnect.Data.UniverseSelection.SecurityChanges) -> None:
+        pass
+
+    def Update(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, data: QuantConnect.Data.Slice) -> typing.List[QuantConnect.Algorithm.Framework.Alphas.Insight]:
+        pass
+
+    @typing.overload
+    def __init__(self, type: QuantConnect.Algorithm.Framework.Alphas.InsightType, direction: QuantConnect.Algorithm.Framework.Alphas.InsightDirection, period: datetime.timedelta) -> QuantConnect.Algorithm.Framework.Alphas.ConstantAlphaModel:
+        pass
+
+    @typing.overload
+    def __init__(self, type: QuantConnect.Algorithm.Framework.Alphas.InsightType, direction: QuantConnect.Algorithm.Framework.Alphas.InsightDirection, period: datetime.timedelta, magnitude: typing.Optional[float], confidence: typing.Optional[float], weight: typing.Optional[float]) -> QuantConnect.Algorithm.Framework.Alphas.ConstantAlphaModel:
+        pass
+
+    def __init__(self, *args) -> QuantConnect.Algorithm.Framework.Alphas.ConstantAlphaModel:
+        pass
+
+
+class EmaCrossAlphaModel(QuantConnect.Algorithm.Framework.Alphas.AlphaModel, QuantConnect.Algorithm.Framework.INotifiedSecurityChanges, QuantConnect.Algorithm.Framework.Alphas.IAlphaModel, QuantConnect.Algorithm.Framework.Alphas.INamedModel):
+    """
+    Alpha model that uses an EMA cross to create insights
+    
+    EmaCrossAlphaModel(fastPeriod: int, slowPeriod: int, resolution: Resolution)
+    """
+    def OnSecuritiesChanged(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, changes: QuantConnect.Data.UniverseSelection.SecurityChanges) -> None:
+        pass
+
+    def Update(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, data: QuantConnect.Data.Slice) -> typing.List[QuantConnect.Algorithm.Framework.Alphas.Insight]:
+        pass
+
+    def __init__(self, fastPeriod: int, slowPeriod: int, resolution: QuantConnect.Resolution) -> QuantConnect.Algorithm.Framework.Alphas.EmaCrossAlphaModel:
+        pass
+
+
+class GeneratedInsightsCollection(System.object):
+    """
+    Defines a collection of insights that were generated at the same time step
+    
+    GeneratedInsightsCollection(dateTimeUtc: DateTime, insights: IEnumerable[Insight], clone: bool)
+    """
+    def __init__(self, dateTimeUtc: datetime.datetime, insights: typing.List[QuantConnect.Algorithm.Framework.Alphas.Insight], clone: bool) -> QuantConnect.Algorithm.Framework.Alphas.GeneratedInsightsCollection:
+        pass
+
+    DateTimeUtc: datetime.datetime
+
+    Insights: typing.List[QuantConnect.Algorithm.Framework.Alphas.Insight]
+
+
+
+class HistoricalReturnsAlphaModel(QuantConnect.Algorithm.Framework.Alphas.AlphaModel, QuantConnect.Algorithm.Framework.INotifiedSecurityChanges, QuantConnect.Algorithm.Framework.Alphas.IAlphaModel, QuantConnect.Algorithm.Framework.Alphas.INamedModel):
+    """
+    Alpha model that uses historical returns to create insights
+    
+    HistoricalReturnsAlphaModel(lookback: int, resolution: Resolution)
+    """
+    def OnSecuritiesChanged(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, changes: QuantConnect.Data.UniverseSelection.SecurityChanges) -> None:
+        pass
+
+    def Update(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, data: QuantConnect.Data.Slice) -> typing.List[QuantConnect.Algorithm.Framework.Alphas.Insight]:
+        pass
+
+    def __init__(self, lookback: int, resolution: QuantConnect.Resolution) -> QuantConnect.Algorithm.Framework.Alphas.HistoricalReturnsAlphaModel:
+        pass
+
+
+class IAlphaModel(QuantConnect.Algorithm.Framework.INotifiedSecurityChanges):
+    """ Algorithm framework model that produces insights """
+    def Update(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, data: QuantConnect.Data.Slice) -> typing.List[QuantConnect.Algorithm.Framework.Alphas.Insight]:
+        pass
+
+
+class IInsightManagerExtension:
+    """
+    Abstraction point to handle the various concerns from a common api.
+                At the time of writing, these concerns are charting, scoring, perisistence and messaging.
+    """
+    def InitializeForRange(self, algorithmStartDate: datetime.datetime, algorithmEndDate: datetime.datetime, algorithmUtcTime: datetime.datetime) -> None:
+        pass
+
+    def OnInsightAnalysisCompleted(self, context: QuantConnect.Algorithm.Framework.Alphas.Analysis.InsightAnalysisContext) -> None:
+        pass
+
+    def OnInsightClosed(self, context: QuantConnect.Algorithm.Framework.Alphas.Analysis.InsightAnalysisContext) -> None:
+        pass
+
+    def OnInsightGenerated(self, context: QuantConnect.Algorithm.Framework.Alphas.Analysis.InsightAnalysisContext) -> None:
+        pass
+
+    def Step(self, frontierTimeUtc: datetime.datetime) -> None:
+        pass

Algorithm.Python/stubs/QuantConnect/Algorithm/Framework/Execution.py

@@ -0,0 +1,109 @@
+import typing
+import QuantConnect.Data.UniverseSelection
+import QuantConnect.Algorithm.Framework.Portfolio
+import QuantConnect.Algorithm.Framework.Execution
+import QuantConnect.Algorithm
+import QuantConnect
+import Python.Runtime
+import datetime
+
+# no functions
+# classes
+
+class ExecutionModel(System.object, QuantConnect.Algorithm.Framework.INotifiedSecurityChanges, QuantConnect.Algorithm.Framework.Execution.IExecutionModel):
+    """
+    Provides a base class for execution models
+    
+    ExecutionModel()
+    """
+    def Execute(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, targets: typing.List[QuantConnect.Algorithm.Framework.Portfolio.IPortfolioTarget]) -> None:
+        pass
+
+    def OnSecuritiesChanged(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, changes: QuantConnect.Data.UniverseSelection.SecurityChanges) -> None:
+        pass
+
+
+class ExecutionModelPythonWrapper(QuantConnect.Algorithm.Framework.Execution.ExecutionModel, QuantConnect.Algorithm.Framework.INotifiedSecurityChanges, QuantConnect.Algorithm.Framework.Execution.IExecutionModel):
+    """
+    Provides an implementation of QuantConnect.Algorithm.Framework.Execution.IExecutionModel that wraps a Python.Runtime.PyObject object
+    
+    ExecutionModelPythonWrapper(model: PyObject)
+    """
+    def Execute(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, targets: typing.List[QuantConnect.Algorithm.Framework.Portfolio.IPortfolioTarget]) -> None:
+        pass
+
+    def OnSecuritiesChanged(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, changes: QuantConnect.Data.UniverseSelection.SecurityChanges) -> None:
+        pass
+
+    def __init__(self, model: Python.Runtime.PyObject) -> QuantConnect.Algorithm.Framework.Execution.ExecutionModelPythonWrapper:
+        pass
+
+
+class IExecutionModel(QuantConnect.Algorithm.Framework.INotifiedSecurityChanges):
+    """ Algorithm framework model that executes portfolio targets """
+    def Execute(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, targets: typing.List[QuantConnect.Algorithm.Framework.Portfolio.IPortfolioTarget]) -> None:
+        pass
+
+
+class ImmediateExecutionModel(QuantConnect.Algorithm.Framework.Execution.ExecutionModel, QuantConnect.Algorithm.Framework.INotifiedSecurityChanges, QuantConnect.Algorithm.Framework.Execution.IExecutionModel):
+    """
+    Provides an implementation of QuantConnect.Algorithm.Framework.Execution.IExecutionModel that immediately submits
+                market orders to achieve the desired portfolio targets
+    
+    ImmediateExecutionModel()
+    """
+    def Execute(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, targets: typing.List[QuantConnect.Algorithm.Framework.Portfolio.IPortfolioTarget]) -> None:
+        pass
+
+    def OnSecuritiesChanged(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, changes: QuantConnect.Data.UniverseSelection.SecurityChanges) -> None:
+        pass
+
+
+class NullExecutionModel(QuantConnect.Algorithm.Framework.Execution.ExecutionModel, QuantConnect.Algorithm.Framework.INotifiedSecurityChanges, QuantConnect.Algorithm.Framework.Execution.IExecutionModel):
+    """
+    Provides an implementation of QuantConnect.Algorithm.Framework.Execution.IExecutionModel that does nothing
+    
+    NullExecutionModel()
+    """
+    def Execute(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, targets: typing.List[QuantConnect.Algorithm.Framework.Portfolio.IPortfolioTarget]) -> None:
+        pass
+
+
+class StandardDeviationExecutionModel(QuantConnect.Algorithm.Framework.Execution.ExecutionModel, QuantConnect.Algorithm.Framework.INotifiedSecurityChanges, QuantConnect.Algorithm.Framework.Execution.IExecutionModel):
+    """
+    Execution model that submits orders while the current market prices is at least the configured number of standard
+                deviations away from the mean in the favorable direction (below/above for buy/sell respectively)
+    
+    StandardDeviationExecutionModel(period: int, deviations: Decimal, resolution: Resolution)
+    """
+    def Execute(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, targets: typing.List[QuantConnect.Algorithm.Framework.Portfolio.IPortfolioTarget]) -> None:
+        pass
+
+    def OnSecuritiesChanged(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, changes: QuantConnect.Data.UniverseSelection.SecurityChanges) -> None:
+        pass
+
+    def __init__(self, period: int, deviations: float, resolution: QuantConnect.Resolution) -> QuantConnect.Algorithm.Framework.Execution.StandardDeviationExecutionModel:
+        pass
+
+    MaximumOrderValue: float
+
+
+    SymbolData: type
+
+
+class VolumeWeightedAveragePriceExecutionModel(QuantConnect.Algorithm.Framework.Execution.ExecutionModel, QuantConnect.Algorithm.Framework.INotifiedSecurityChanges, QuantConnect.Algorithm.Framework.Execution.IExecutionModel):
+    """
+    Execution model that submits orders while the current market price is more favorable that the current volume weighted average price.
+    
+    VolumeWeightedAveragePriceExecutionModel()
+    """
+    def Execute(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, targets: typing.List[QuantConnect.Algorithm.Framework.Portfolio.IPortfolioTarget]) -> None:
+        pass
+
+    def OnSecuritiesChanged(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, changes: QuantConnect.Data.UniverseSelection.SecurityChanges) -> None:
+        pass
+
+    MaximumOrderQuantityPercentVolume: float
+
+
+    SymbolData: type

Algorithm.Python/stubs/QuantConnect/Algorithm/Framework/Portfolio.py

@@ -0,0 +1,149 @@
+from .__Portfolio_1 import *
+import typing
+import System.Collections.Generic
+import System
+import QuantConnect.Scheduling
+import QuantConnect.Interfaces
+import QuantConnect.Data.UniverseSelection
+import QuantConnect.Algorithm.Framework.Portfolio
+import QuantConnect.Algorithm.Framework.Alphas
+import QuantConnect.Algorithm
+import QuantConnect
+import Python.Runtime
+import datetime
+
+# no functions
+# classes
+
+class PortfolioConstructionModel(System.object, QuantConnect.Algorithm.Framework.INotifiedSecurityChanges, QuantConnect.Algorithm.Framework.Portfolio.IPortfolioConstructionModel):
+    """
+    Provides a base class for portfolio construction models
+    
+    PortfolioConstructionModel(rebalancingFunc: Func[DateTime, Nullable[DateTime]])
+    PortfolioConstructionModel(rebalancingFunc: Func[DateTime, DateTime])
+    """
+    def CreateTargets(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, insights: typing.List[QuantConnect.Algorithm.Framework.Alphas.Insight]) -> typing.List[QuantConnect.Algorithm.Framework.Portfolio.IPortfolioTarget]:
+        pass
+
+    def OnSecuritiesChanged(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, changes: QuantConnect.Data.UniverseSelection.SecurityChanges) -> None:
+        pass
+
+    @typing.overload
+    def __init__(self, rebalancingFunc: typing.Callable[[datetime.datetime], typing.Optional[datetime.datetime]]) -> QuantConnect.Algorithm.Framework.Portfolio.PortfolioConstructionModel:
+        pass
+
+    @typing.overload
+    def __init__(self, rebalancingFunc: typing.Callable[[datetime.datetime], datetime.datetime]) -> QuantConnect.Algorithm.Framework.Portfolio.PortfolioConstructionModel:
+        pass
+
+    def __init__(self, *args) -> QuantConnect.Algorithm.Framework.Portfolio.PortfolioConstructionModel:
+        pass
+
+    RebalanceOnInsightChanges: bool
+
+    RebalanceOnSecurityChanges: bool
+
+    PythonWrapper: QuantConnect.Algorithm.Framework.Portfolio.PortfolioConstructionModelPythonWrapper
+
+
+class AccumulativeInsightPortfolioConstructionModel(QuantConnect.Algorithm.Framework.Portfolio.PortfolioConstructionModel, QuantConnect.Algorithm.Framework.INotifiedSecurityChanges, QuantConnect.Algorithm.Framework.Portfolio.IPortfolioConstructionModel):
+    """
+    Provides an implementation of QuantConnect.Algorithm.Framework.Portfolio.IPortfolioConstructionModel that allocates percent of account
+                to each insight, defaulting to 3%.
+                For insights of direction QuantConnect.Algorithm.Framework.Alphas.InsightDirection.Up, long targets are returned and
+                for insights of direction QuantConnect.Algorithm.Framework.Alphas.InsightDirection.Down, short targets are returned.
+                By default, no rebalancing shall be done.
+                Rules:
+                   1. On active Up insight, increase position size by percent
+                   2. On active Down insight, decrease position size by percent
+                   3. On active Flat insight, move by percent towards 0
+                   4. On expired insight, and no other active insight, emits a 0 target'''
+    
+    AccumulativeInsightPortfolioConstructionModel(rebalancingDateRules: IDateRule, portfolioBias: PortfolioBias, percent: float)
+    AccumulativeInsightPortfolioConstructionModel(rebalancingFunc: Func[DateTime, Nullable[DateTime]], portfolioBias: PortfolioBias, percent: float)
+    AccumulativeInsightPortfolioConstructionModel(rebalancingFunc: Func[DateTime, DateTime], portfolioBias: PortfolioBias, percent: float)
+    AccumulativeInsightPortfolioConstructionModel(rebalance: PyObject, portfolioBias: PortfolioBias, percent: float)
+    AccumulativeInsightPortfolioConstructionModel(timeSpan: TimeSpan, portfolioBias: PortfolioBias, percent: float)
+    AccumulativeInsightPortfolioConstructionModel(resolution: Resolution, portfolioBias: PortfolioBias, percent: float)
+    """
+    @typing.overload
+    def __init__(self, rebalancingDateRules: QuantConnect.Scheduling.IDateRule, portfolioBias: QuantConnect.Algorithm.Framework.Portfolio.PortfolioBias, percent: float) -> QuantConnect.Algorithm.Framework.Portfolio.AccumulativeInsightPortfolioConstructionModel:
+        pass
+
+    @typing.overload
+    def __init__(self, rebalancingFunc: typing.Callable[[datetime.datetime], typing.Optional[datetime.datetime]], portfolioBias: QuantConnect.Algorithm.Framework.Portfolio.PortfolioBias, percent: float) -> QuantConnect.Algorithm.Framework.Portfolio.AccumulativeInsightPortfolioConstructionModel:
+        pass
+
+    @typing.overload
+    def __init__(self, rebalancingFunc: typing.Callable[[datetime.datetime], datetime.datetime], portfolioBias: QuantConnect.Algorithm.Framework.Portfolio.PortfolioBias, percent: float) -> QuantConnect.Algorithm.Framework.Portfolio.AccumulativeInsightPortfolioConstructionModel:
+        pass
+
+    @typing.overload
+    def __init__(self, rebalance: Python.Runtime.PyObject, portfolioBias: QuantConnect.Algorithm.Framework.Portfolio.PortfolioBias, percent: float) -> QuantConnect.Algorithm.Framework.Portfolio.AccumulativeInsightPortfolioConstructionModel:
+        pass
+
+    @typing.overload
+    def __init__(self, timeSpan: datetime.timedelta, portfolioBias: QuantConnect.Algorithm.Framework.Portfolio.PortfolioBias, percent: float) -> QuantConnect.Algorithm.Framework.Portfolio.AccumulativeInsightPortfolioConstructionModel:
+        pass
+
+    @typing.overload
+    def __init__(self, resolution: QuantConnect.Resolution, portfolioBias: QuantConnect.Algorithm.Framework.Portfolio.PortfolioBias, percent: float) -> QuantConnect.Algorithm.Framework.Portfolio.AccumulativeInsightPortfolioConstructionModel:
+        pass
+
+    def __init__(self, *args) -> QuantConnect.Algorithm.Framework.Portfolio.AccumulativeInsightPortfolioConstructionModel:
+        pass
+
+    PythonWrapper: QuantConnect.Algorithm.Framework.Portfolio.PortfolioConstructionModelPythonWrapper
+
+
+class BlackLittermanOptimizationPortfolioConstructionModel(QuantConnect.Algorithm.Framework.Portfolio.PortfolioConstructionModel, QuantConnect.Algorithm.Framework.INotifiedSecurityChanges, QuantConnect.Algorithm.Framework.Portfolio.IPortfolioConstructionModel):
+    """
+    Provides an implementation of Black-Litterman portfolio optimization. The model adjusts equilibrium market
+                returns by incorporating views from multiple alpha models and therefore to get the optimal risky portfolio
+                reflecting those views. If insights of all alpha models have None magnitude or there are linearly dependent
+                vectors in link matrix of views, the expected return would be the implied excess equilibrium return.
+                The interval of weights in optimization method can be changed based on the long-short algorithm.
+                The default model uses the 0.0025 as weight-on-views scalar parameter tau. The optimization method
+                maximizes the Sharpe ratio with the weight range from -1 to 1.
+    
+    BlackLittermanOptimizationPortfolioConstructionModel(timeSpan: TimeSpan, portfolioBias: PortfolioBias, lookback: int, period: int, resolution: Resolution, riskFreeRate: float, delta: float, tau: float, optimizer: IPortfolioOptimizer)
+    BlackLittermanOptimizationPortfolioConstructionModel(rebalanceResolution: Resolution, portfolioBias: PortfolioBias, lookback: int, period: int, resolution: Resolution, riskFreeRate: float, delta: float, tau: float, optimizer: IPortfolioOptimizer)
+    BlackLittermanOptimizationPortfolioConstructionModel(rebalancingFunc: Func[DateTime, DateTime], portfolioBias: PortfolioBias, lookback: int, period: int, resolution: Resolution, riskFreeRate: float, delta: float, tau: float, optimizer: IPortfolioOptimizer)
+    BlackLittermanOptimizationPortfolioConstructionModel(rebalancingDateRules: IDateRule, portfolioBias: PortfolioBias, lookback: int, period: int, resolution: Resolution, riskFreeRate: float, delta: float, tau: float, optimizer: IPortfolioOptimizer)
+    BlackLittermanOptimizationPortfolioConstructionModel(rebalance: PyObject, portfolioBias: PortfolioBias, lookback: int, period: int, resolution: Resolution, riskFreeRate: float, delta: float, tau: float, optimizer: IPortfolioOptimizer)
+    BlackLittermanOptimizationPortfolioConstructionModel(rebalancingFunc: Func[DateTime, Nullable[DateTime]], portfolioBias: PortfolioBias, lookback: int, period: int, resolution: Resolution, riskFreeRate: float, delta: float, tau: float, optimizer: IPortfolioOptimizer)
+    """
+    def GetEquilibriumReturns(self, returns: typing.List[typing.List[float]], Σ: typing.List[typing.List[float]]) -> typing.List[float]:
+        pass
+
+    def OnSecuritiesChanged(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, changes: QuantConnect.Data.UniverseSelection.SecurityChanges) -> None:
+        pass
+
+    @typing.overload
+    def __init__(self, timeSpan: datetime.timedelta, portfolioBias: QuantConnect.Algorithm.Framework.Portfolio.PortfolioBias, lookback: int, period: int, resolution: QuantConnect.Resolution, riskFreeRate: float, delta: float, tau: float, optimizer: QuantConnect.Algorithm.Framework.Portfolio.IPortfolioOptimizer) -> QuantConnect.Algorithm.Framework.Portfolio.BlackLittermanOptimizationPortfolioConstructionModel:
+        pass
+
+    @typing.overload
+    def __init__(self, rebalanceResolution: QuantConnect.Resolution, portfolioBias: QuantConnect.Algorithm.Framework.Portfolio.PortfolioBias, lookback: int, period: int, resolution: QuantConnect.Resolution, riskFreeRate: float, delta: float, tau: float, optimizer: QuantConnect.Algorithm.Framework.Portfolio.IPortfolioOptimizer) -> QuantConnect.Algorithm.Framework.Portfolio.BlackLittermanOptimizationPortfolioConstructionModel:
+        pass
+
+    @typing.overload
+    def __init__(self, rebalancingFunc: typing.Callable[[datetime.datetime], datetime.datetime], portfolioBias: QuantConnect.Algorithm.Framework.Portfolio.PortfolioBias, lookback: int, period: int, resolution: QuantConnect.Resolution, riskFreeRate: float, delta: float, tau: float, optimizer: QuantConnect.Algorithm.Framework.Portfolio.IPortfolioOptimizer) -> QuantConnect.Algorithm.Framework.Portfolio.BlackLittermanOptimizationPortfolioConstructionModel:
+        pass
+
+    @typing.overload
+    def __init__(self, rebalancingDateRules: QuantConnect.Scheduling.IDateRule, portfolioBias: QuantConnect.Algorithm.Framework.Portfolio.PortfolioBias, lookback: int, period: int, resolution: QuantConnect.Resolution, riskFreeRate: float, delta: float, tau: float, optimizer: QuantConnect.Algorithm.Framework.Portfolio.IPortfolioOptimizer) -> QuantConnect.Algorithm.Framework.Portfolio.BlackLittermanOptimizationPortfolioConstructionModel:
+        pass
+
+    @typing.overload
+    def __init__(self, rebalance: Python.Runtime.PyObject, portfolioBias: QuantConnect.Algorithm.Framework.Portfolio.PortfolioBias, lookback: int, period: int, resolution: QuantConnect.Resolution, riskFreeRate: float, delta: float, tau: float, optimizer: QuantConnect.Algorithm.Framework.Portfolio.IPortfolioOptimizer) -> QuantConnect.Algorithm.Framework.Portfolio.BlackLittermanOptimizationPortfolioConstructionModel:
+        pass
+
+    @typing.overload
+    def __init__(self, rebalancingFunc: typing.Callable[[datetime.datetime], typing.Optional[datetime.datetime]], portfolioBias: QuantConnect.Algorithm.Framework.Portfolio.PortfolioBias, lookback: int, period: int, resolution: QuantConnect.Resolution, riskFreeRate: float, delta: float, tau: float, optimizer: QuantConnect.Algorithm.Framework.Portfolio.IPortfolioOptimizer) -> QuantConnect.Algorithm.Framework.Portfolio.BlackLittermanOptimizationPortfolioConstructionModel:
+        pass
+
+    def __init__(self, *args) -> QuantConnect.Algorithm.Framework.Portfolio.BlackLittermanOptimizationPortfolioConstructionModel:
+        pass
+
+    PythonWrapper: QuantConnect.Algorithm.Framework.Portfolio.PortfolioConstructionModelPythonWrapper

Algorithm.Python/stubs/QuantConnect/Algorithm/Framework/Risk.py

@@ -0,0 +1,174 @@
+import typing
+import QuantConnect.Data.UniverseSelection
+import QuantConnect.Algorithm.Framework.Risk
+import QuantConnect.Algorithm.Framework.Portfolio
+import QuantConnect.Algorithm
+import Python.Runtime
+import datetime
+
+# no functions
+# classes
+
+class RiskManagementModel(System.object, QuantConnect.Algorithm.Framework.INotifiedSecurityChanges, QuantConnect.Algorithm.Framework.Risk.IRiskManagementModel):
+    """
+    Provides a base class for risk management models
+    
+    RiskManagementModel()
+    """
+    def ManageRisk(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, targets: typing.List[QuantConnect.Algorithm.Framework.Portfolio.IPortfolioTarget]) -> typing.List[QuantConnect.Algorithm.Framework.Portfolio.IPortfolioTarget]:
+        pass
+
+    def OnSecuritiesChanged(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, changes: QuantConnect.Data.UniverseSelection.SecurityChanges) -> None:
+        pass
+
+
+class CompositeRiskManagementModel(QuantConnect.Algorithm.Framework.Risk.RiskManagementModel, QuantConnect.Algorithm.Framework.INotifiedSecurityChanges, QuantConnect.Algorithm.Framework.Risk.IRiskManagementModel):
+    """
+    Provides an implementation of QuantConnect.Algorithm.Framework.Risk.IRiskManagementModel that combines multiple risk
+                models into a single risk management model and properly sets each insights 'SourceModel' property.
+    
+    CompositeRiskManagementModel(*riskManagementModels: Array[IRiskManagementModel])
+    CompositeRiskManagementModel(riskManagementModels: IEnumerable[IRiskManagementModel])
+    CompositeRiskManagementModel(*riskManagementModels: Array[PyObject])
+    CompositeRiskManagementModel(riskManagementModel: PyObject)
+    """
+    @typing.overload
+    def AddRiskManagement(self, riskManagementModel: QuantConnect.Algorithm.Framework.Risk.IRiskManagementModel) -> None:
+        pass
+
+    @typing.overload
+    def AddRiskManagement(self, pyRiskManagementModel: Python.Runtime.PyObject) -> None:
+        pass
+
+    def AddRiskManagement(self, *args) -> None:
+        pass
+
+    def ManageRisk(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, targets: typing.List[QuantConnect.Algorithm.Framework.Portfolio.IPortfolioTarget]) -> typing.List[QuantConnect.Algorithm.Framework.Portfolio.IPortfolioTarget]:
+        pass
+
+    def OnSecuritiesChanged(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, changes: QuantConnect.Data.UniverseSelection.SecurityChanges) -> None:
+        pass
+
+    @typing.overload
+    def __init__(self, riskManagementModels: typing.List[QuantConnect.Algorithm.Framework.Risk.IRiskManagementModel]) -> QuantConnect.Algorithm.Framework.Risk.CompositeRiskManagementModel:
+        pass
+
+    @typing.overload
+    def __init__(self, riskManagementModels: typing.List[QuantConnect.Algorithm.Framework.Risk.IRiskManagementModel]) -> QuantConnect.Algorithm.Framework.Risk.CompositeRiskManagementModel:
+        pass
+
+    @typing.overload
+    def __init__(self, riskManagementModels: typing.List[Python.Runtime.PyObject]) -> QuantConnect.Algorithm.Framework.Risk.CompositeRiskManagementModel:
+        pass
+
+    @typing.overload
+    def __init__(self, riskManagementModel: Python.Runtime.PyObject) -> QuantConnect.Algorithm.Framework.Risk.CompositeRiskManagementModel:
+        pass
+
+    def __init__(self, *args) -> QuantConnect.Algorithm.Framework.Risk.CompositeRiskManagementModel:
+        pass
+
+
+class IRiskManagementModel(QuantConnect.Algorithm.Framework.INotifiedSecurityChanges):
+    """ Algorithm framework model that manages an algorithm's risk/downside """
+    def ManageRisk(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, targets: typing.List[QuantConnect.Algorithm.Framework.Portfolio.IPortfolioTarget]) -> typing.List[QuantConnect.Algorithm.Framework.Portfolio.IPortfolioTarget]:
+        pass
+
+
+class MaximumDrawdownPercentPerSecurity(QuantConnect.Algorithm.Framework.Risk.RiskManagementModel, QuantConnect.Algorithm.Framework.INotifiedSecurityChanges, QuantConnect.Algorithm.Framework.Risk.IRiskManagementModel):
+    """
+    Provides an implementation of QuantConnect.Algorithm.Framework.Risk.IRiskManagementModel that limits the drawdown
+                per holding to the specified percentage
+    
+    MaximumDrawdownPercentPerSecurity(maximumDrawdownPercent: Decimal)
+    """
+    def ManageRisk(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, targets: typing.List[QuantConnect.Algorithm.Framework.Portfolio.IPortfolioTarget]) -> typing.List[QuantConnect.Algorithm.Framework.Portfolio.IPortfolioTarget]:
+        pass
+
+    def __init__(self, maximumDrawdownPercent: float) -> QuantConnect.Algorithm.Framework.Risk.MaximumDrawdownPercentPerSecurity:
+        pass
+
+
+class MaximumDrawdownPercentPortfolio(QuantConnect.Algorithm.Framework.Risk.RiskManagementModel, QuantConnect.Algorithm.Framework.INotifiedSecurityChanges, QuantConnect.Algorithm.Framework.Risk.IRiskManagementModel):
+    """
+    Provides an implementation of QuantConnect.Algorithm.Framework.Risk.IRiskManagementModel that limits the drawdown of the portfolio
+                to the specified percentage. Once this is triggered the algorithm will need to be manually restarted.
+    
+    MaximumDrawdownPercentPortfolio(maximumDrawdownPercent: Decimal, isTrailing: bool)
+    """
+    def ManageRisk(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, targets: typing.List[QuantConnect.Algorithm.Framework.Portfolio.IPortfolioTarget]) -> typing.List[QuantConnect.Algorithm.Framework.Portfolio.IPortfolioTarget]:
+        pass
+
+    def __init__(self, maximumDrawdownPercent: float, isTrailing: bool) -> QuantConnect.Algorithm.Framework.Risk.MaximumDrawdownPercentPortfolio:
+        pass
+
+
+class MaximumSectorExposureRiskManagementModel(QuantConnect.Algorithm.Framework.Risk.RiskManagementModel, QuantConnect.Algorithm.Framework.INotifiedSecurityChanges, QuantConnect.Algorithm.Framework.Risk.IRiskManagementModel):
+    """
+    Provides an implementation of QuantConnect.Algorithm.Framework.Risk.IRiskManagementModel that limits
+                the sector exposure to the specified percentage
+    
+    MaximumSectorExposureRiskManagementModel(maximumSectorExposure: Decimal)
+    """
+    def ManageRisk(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, targets: typing.List[QuantConnect.Algorithm.Framework.Portfolio.IPortfolioTarget]) -> typing.List[QuantConnect.Algorithm.Framework.Portfolio.IPortfolioTarget]:
+        pass
+
+    def OnSecuritiesChanged(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, changes: QuantConnect.Data.UniverseSelection.SecurityChanges) -> None:
+        pass
+
+    def __init__(self, maximumSectorExposure: float) -> QuantConnect.Algorithm.Framework.Risk.MaximumSectorExposureRiskManagementModel:
+        pass
+
+
+class MaximumUnrealizedProfitPercentPerSecurity(QuantConnect.Algorithm.Framework.Risk.RiskManagementModel, QuantConnect.Algorithm.Framework.INotifiedSecurityChanges, QuantConnect.Algorithm.Framework.Risk.IRiskManagementModel):
+    """
+    Provides an implementation of QuantConnect.Algorithm.Framework.Risk.IRiskManagementModel that limits the unrealized profit
+                per holding to the specified percentage
+    
+    MaximumUnrealizedProfitPercentPerSecurity(maximumUnrealizedProfitPercent: Decimal)
+    """
+    def ManageRisk(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, targets: typing.List[QuantConnect.Algorithm.Framework.Portfolio.IPortfolioTarget]) -> typing.List[QuantConnect.Algorithm.Framework.Portfolio.IPortfolioTarget]:
+        pass
+
+    def __init__(self, maximumUnrealizedProfitPercent: float) -> QuantConnect.Algorithm.Framework.Risk.MaximumUnrealizedProfitPercentPerSecurity:
+        pass
+
+
+class NullRiskManagementModel(QuantConnect.Algorithm.Framework.Risk.RiskManagementModel, QuantConnect.Algorithm.Framework.INotifiedSecurityChanges, QuantConnect.Algorithm.Framework.Risk.IRiskManagementModel):
+    """
+    Provides an implementation of QuantConnect.Algorithm.Framework.Risk.IRiskManagementModel that does nothing
+    
+    NullRiskManagementModel()
+    """
+    def ManageRisk(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, targets: typing.List[QuantConnect.Algorithm.Framework.Portfolio.IPortfolioTarget]) -> typing.List[QuantConnect.Algorithm.Framework.Portfolio.IPortfolioTarget]:
+        pass
+
+
+class RiskManagementModelPythonWrapper(QuantConnect.Algorithm.Framework.Risk.RiskManagementModel, QuantConnect.Algorithm.Framework.INotifiedSecurityChanges, QuantConnect.Algorithm.Framework.Risk.IRiskManagementModel):
+    """
+    Provides an implementation of QuantConnect.Algorithm.Framework.Risk.IRiskManagementModel that wraps a Python.Runtime.PyObject object
+    
+    RiskManagementModelPythonWrapper(model: PyObject)
+    """
+    def ManageRisk(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, targets: typing.List[QuantConnect.Algorithm.Framework.Portfolio.IPortfolioTarget]) -> typing.List[QuantConnect.Algorithm.Framework.Portfolio.IPortfolioTarget]:
+        pass
+
+    def OnSecuritiesChanged(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, changes: QuantConnect.Data.UniverseSelection.SecurityChanges) -> None:
+        pass
+
+    def __init__(self, model: Python.Runtime.PyObject) -> QuantConnect.Algorithm.Framework.Risk.RiskManagementModelPythonWrapper:
+        pass
+
+
+class TrailingStopRiskManagementModel(QuantConnect.Algorithm.Framework.Risk.RiskManagementModel, QuantConnect.Algorithm.Framework.INotifiedSecurityChanges, QuantConnect.Algorithm.Framework.Risk.IRiskManagementModel):
+    """
+    Provides an implementation of QuantConnect.Algorithm.Framework.Risk.IRiskManagementModel that limits the maximum possible loss
+                measured from the highest unrealized profit
+    
+    TrailingStopRiskManagementModel(maximumDrawdownPercent: Decimal)
+    """
+    def ManageRisk(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, targets: typing.List[QuantConnect.Algorithm.Framework.Portfolio.IPortfolioTarget]) -> typing.List[QuantConnect.Algorithm.Framework.Portfolio.IPortfolioTarget]:
+        pass
+
+    def __init__(self, maximumDrawdownPercent: float) -> QuantConnect.Algorithm.Framework.Risk.TrailingStopRiskManagementModel:
+        pass

Algorithm.Python/stubs/QuantConnect/Algorithm/Framework/Selection.py

@@ -0,0 +1,195 @@
+from .__Selection_1 import *
+import typing
+import System.Collections.Generic
+import System
+import QuantConnect.Securities
+import QuantConnect.Scheduling
+import QuantConnect.Interfaces
+import QuantConnect.Data.UniverseSelection
+import QuantConnect.Data.Fundamental
+import QuantConnect.Data
+import QuantConnect.Algorithm.Framework.Selection
+import QuantConnect.Algorithm
+import QuantConnect
+import Python.Runtime
+import NodaTime
+import datetime
+
+# no functions
+# classes
+
+class UniverseSelectionModel(System.object, QuantConnect.Algorithm.Framework.Selection.IUniverseSelectionModel):
+    """
+    Provides a base class for universe selection models.
+    
+    UniverseSelectionModel()
+    """
+    def CreateUniverses(self, algorithm: QuantConnect.Algorithm.QCAlgorithm) -> typing.List[QuantConnect.Data.UniverseSelection.Universe]:
+        pass
+
+    def GetNextRefreshTimeUtc(self) -> datetime.datetime:
+        pass
+
+
+class FundamentalUniverseSelectionModel(QuantConnect.Algorithm.Framework.Selection.UniverseSelectionModel, QuantConnect.Algorithm.Framework.Selection.IUniverseSelectionModel):
+    """ Provides a base class for defining equity coarse/fine fundamental selection models """
+    @staticmethod
+    def Coarse(coarseSelector: typing.Callable[[typing.List[QuantConnect.Data.UniverseSelection.CoarseFundamental]], typing.List[QuantConnect.Symbol]]) -> QuantConnect.Algorithm.Framework.Selection.IUniverseSelectionModel:
+        pass
+
+    def CreateCoarseFundamentalUniverse(self, algorithm: QuantConnect.Algorithm.QCAlgorithm) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def CreateUniverses(self, algorithm: QuantConnect.Algorithm.QCAlgorithm) -> typing.List[QuantConnect.Data.UniverseSelection.Universe]:
+        pass
+
+    @staticmethod
+    def Fine(coarseSelector: typing.Callable[[typing.List[QuantConnect.Data.UniverseSelection.CoarseFundamental]], typing.List[QuantConnect.Symbol]], fineSelector: typing.Callable[[typing.List[QuantConnect.Data.Fundamental.FineFundamental]], typing.List[QuantConnect.Symbol]]) -> QuantConnect.Algorithm.Framework.Selection.IUniverseSelectionModel:
+        pass
+
+    def SelectCoarse(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, coarse: typing.List[QuantConnect.Data.UniverseSelection.CoarseFundamental]) -> typing.List[QuantConnect.Symbol]:
+        pass
+
+    def SelectFine(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, fine: typing.List[QuantConnect.Data.Fundamental.FineFundamental]) -> typing.List[QuantConnect.Symbol]:
+        pass
+
+    def __init__(self, *args): #cannot find CLR constructor
+        pass
+
+
+class CoarseFundamentalUniverseSelectionModel(QuantConnect.Algorithm.Framework.Selection.FundamentalUniverseSelectionModel, QuantConnect.Algorithm.Framework.Selection.IUniverseSelectionModel):
+    """
+    Portfolio selection model that uses coarse selectors. For US equities only.
+    
+    CoarseFundamentalUniverseSelectionModel(coarseSelector: Func[IEnumerable[CoarseFundamental], IEnumerable[Symbol]], universeSettings: UniverseSettings, securityInitializer: ISecurityInitializer)
+    CoarseFundamentalUniverseSelectionModel(coarseSelector: PyObject, universeSettings: UniverseSettings, securityInitializer: ISecurityInitializer)
+    """
+    def SelectCoarse(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, coarse: typing.List[QuantConnect.Data.UniverseSelection.CoarseFundamental]) -> typing.List[QuantConnect.Symbol]:
+        pass
+
+    @typing.overload
+    def __init__(self, coarseSelector: typing.Callable[[typing.List[QuantConnect.Data.UniverseSelection.CoarseFundamental]], typing.List[QuantConnect.Symbol]], universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings, securityInitializer: QuantConnect.Securities.ISecurityInitializer) -> QuantConnect.Algorithm.Framework.Selection.CoarseFundamentalUniverseSelectionModel:
+        pass
+
+    @typing.overload
+    def __init__(self, coarseSelector: Python.Runtime.PyObject, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings, securityInitializer: QuantConnect.Securities.ISecurityInitializer) -> QuantConnect.Algorithm.Framework.Selection.CoarseFundamentalUniverseSelectionModel:
+        pass
+
+    def __init__(self, *args) -> QuantConnect.Algorithm.Framework.Selection.CoarseFundamentalUniverseSelectionModel:
+        pass
+
+
+class CompositeUniverseSelectionModel(QuantConnect.Algorithm.Framework.Selection.UniverseSelectionModel, QuantConnect.Algorithm.Framework.Selection.IUniverseSelectionModel):
+    """
+    Provides an implementation of QuantConnect.Algorithm.Framework.Selection.IUniverseSelectionModel that combines multiple universe
+                selection models into a single model.
+    
+    CompositeUniverseSelectionModel(*universeSelectionModels: Array[IUniverseSelectionModel])
+    CompositeUniverseSelectionModel(*universeSelectionModels: Array[PyObject])
+    CompositeUniverseSelectionModel(universeSelectionModel: PyObject)
+    """
+    @typing.overload
+    def AddUniverseSelection(self, universeSelectionModel: QuantConnect.Algorithm.Framework.Selection.IUniverseSelectionModel) -> None:
+        pass
+
+    @typing.overload
+    def AddUniverseSelection(self, pyUniverseSelectionModel: Python.Runtime.PyObject) -> None:
+        pass
+
+    def AddUniverseSelection(self, *args) -> None:
+        pass
+
+    def CreateUniverses(self, algorithm: QuantConnect.Algorithm.QCAlgorithm) -> typing.List[QuantConnect.Data.UniverseSelection.Universe]:
+        pass
+
+    def GetNextRefreshTimeUtc(self) -> datetime.datetime:
+        pass
+
+    @typing.overload
+    def __init__(self, universeSelectionModels: typing.List[QuantConnect.Algorithm.Framework.Selection.IUniverseSelectionModel]) -> QuantConnect.Algorithm.Framework.Selection.CompositeUniverseSelectionModel:
+        pass
+
+    @typing.overload
+    def __init__(self, universeSelectionModels: typing.List[Python.Runtime.PyObject]) -> QuantConnect.Algorithm.Framework.Selection.CompositeUniverseSelectionModel:
+        pass
+
+    @typing.overload
+    def __init__(self, universeSelectionModel: Python.Runtime.PyObject) -> QuantConnect.Algorithm.Framework.Selection.CompositeUniverseSelectionModel:
+        pass
+
+    def __init__(self, *args) -> QuantConnect.Algorithm.Framework.Selection.CompositeUniverseSelectionModel:
+        pass
+
+
+class CustomUniverse(QuantConnect.Data.UniverseSelection.UserDefinedUniverse, System.IDisposable, QuantConnect.Data.UniverseSelection.ITimeTriggeredUniverse, System.Collections.Specialized.INotifyCollectionChanged):
+    """
+    Defines a universe as a set of dynamically set symbols.
+    
+    CustomUniverse(configuration: SubscriptionDataConfig, universeSettings: UniverseSettings, interval: TimeSpan, selector: Func[DateTime, IEnumerable[str]])
+    """
+    @typing.overload
+    def GetSubscriptionRequests(self, security: QuantConnect.Securities.Security, currentTimeUtc: datetime.datetime, maximumEndTimeUtc: datetime.datetime, subscriptionService: QuantConnect.Interfaces.ISubscriptionDataConfigService) -> typing.List[QuantConnect.Data.UniverseSelection.SubscriptionRequest]:
+        pass
+
+    @typing.overload
+    def GetSubscriptionRequests(self, security: QuantConnect.Securities.Security, currentTimeUtc: datetime.datetime, maximumEndTimeUtc: datetime.datetime) -> typing.List[QuantConnect.Data.UniverseSelection.SubscriptionRequest]:
+        pass
+
+    def GetSubscriptionRequests(self, *args) -> typing.List[QuantConnect.Data.UniverseSelection.SubscriptionRequest]:
+        pass
+
+    def __init__(self, configuration: QuantConnect.Data.SubscriptionDataConfig, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings, interval: datetime.timedelta, selector: typing.Callable[[datetime.datetime], typing.List[str]]) -> QuantConnect.Algorithm.Framework.Selection.CustomUniverse:
+        pass
+
+
+class CustomUniverseSelectionModel(QuantConnect.Algorithm.Framework.Selection.UniverseSelectionModel, QuantConnect.Algorithm.Framework.Selection.IUniverseSelectionModel):
+    """
+    Provides an implementation of QuantConnect.Algorithm.Framework.Selection.IUniverseSelectionModel that simply
+                subscribes to the specified set of symbols
+    
+    CustomUniverseSelectionModel(name: str, selector: Func[DateTime, IEnumerable[str]])
+    CustomUniverseSelectionModel(name: str, selector: PyObject)
+    CustomUniverseSelectionModel(securityType: SecurityType, name: str, market: str, selector: Func[DateTime, IEnumerable[str]], universeSettings: UniverseSettings, interval: TimeSpan)
+    CustomUniverseSelectionModel(securityType: SecurityType, name: str, market: str, selector: PyObject, universeSettings: UniverseSettings, interval: TimeSpan)
+    """
+    def CreateUniverses(self, algorithm: QuantConnect.Algorithm.QCAlgorithm) -> typing.List[QuantConnect.Data.UniverseSelection.Universe]:
+        pass
+
+    def Select(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, date: datetime.datetime) -> typing.List[str]:
+        pass
+
+    def ToString(self) -> str:
+        pass
+
+    @typing.overload
+    def __init__(self, name: str, selector: typing.Callable[[datetime.datetime], typing.List[str]]) -> QuantConnect.Algorithm.Framework.Selection.CustomUniverseSelectionModel:
+        pass
+
+    @typing.overload
+    def __init__(self, name: str, selector: Python.Runtime.PyObject) -> QuantConnect.Algorithm.Framework.Selection.CustomUniverseSelectionModel:
+        pass
+
+    @typing.overload
+    def __init__(self, securityType: QuantConnect.SecurityType, name: str, market: str, selector: typing.Callable[[datetime.datetime], typing.List[str]], universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings, interval: datetime.timedelta) -> QuantConnect.Algorithm.Framework.Selection.CustomUniverseSelectionModel:
+        pass
+
+    @typing.overload
+    def __init__(self, securityType: QuantConnect.SecurityType, name: str, market: str, selector: Python.Runtime.PyObject, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings, interval: datetime.timedelta) -> QuantConnect.Algorithm.Framework.Selection.CustomUniverseSelectionModel:
+        pass
+
+    def __init__(self, *args) -> QuantConnect.Algorithm.Framework.Selection.CustomUniverseSelectionModel:
+        pass
+
+
+class EmaCrossUniverseSelectionModel(QuantConnect.Algorithm.Framework.Selection.FundamentalUniverseSelectionModel, QuantConnect.Algorithm.Framework.Selection.IUniverseSelectionModel):
+    """
+    Provides an implementation of QuantConnect.Algorithm.Framework.Selection.FundamentalUniverseSelectionModel that subscribes
+                to symbols with the larger delta by percentage between the two exponential moving average
+    
+    EmaCrossUniverseSelectionModel(fastPeriod: int, slowPeriod: int, universeCount: int, universeSettings: UniverseSettings, securityInitializer: ISecurityInitializer)
+    """
+    def SelectCoarse(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, coarse: typing.List[QuantConnect.Data.UniverseSelection.CoarseFundamental]) -> typing.List[QuantConnect.Symbol]:
+        pass
+
+    def __init__(self, fastPeriod: int, slowPeriod: int, universeCount: int, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings, securityInitializer: QuantConnect.Securities.ISecurityInitializer) -> QuantConnect.Algorithm.Framework.Selection.EmaCrossUniverseSelectionModel:
+        pass

Algorithm.Python/stubs/QuantConnect/Algorithm/Framework/__Portfolio_1.py

@@ -0,0 +1,153 @@
+from .__Portfolio_2 import *
+import typing
+import System.Collections.Generic
+import System
+import QuantConnect.Scheduling
+import QuantConnect.Interfaces
+import QuantConnect.Data.UniverseSelection
+import QuantConnect.Algorithm.Framework.Portfolio
+import QuantConnect.Algorithm.Framework.Alphas
+import QuantConnect.Algorithm
+import QuantConnect
+import Python.Runtime
+import datetime
+
+
+class EqualWeightingPortfolioConstructionModel(QuantConnect.Algorithm.Framework.Portfolio.PortfolioConstructionModel, QuantConnect.Algorithm.Framework.INotifiedSecurityChanges, QuantConnect.Algorithm.Framework.Portfolio.IPortfolioConstructionModel):
+    """
+    Provides an implementation of QuantConnect.Algorithm.Framework.Portfolio.IPortfolioConstructionModel that gives equal weighting to all
+                securities. The target percent holdings of each security is 1/N where N is the number of securities. For
+                insights of direction QuantConnect.Algorithm.Framework.Alphas.InsightDirection.Up, long targets are returned and for insights of direction
+                QuantConnect.Algorithm.Framework.Alphas.InsightDirection.Down, short targets are returned.
+    
+    EqualWeightingPortfolioConstructionModel(rebalancingDateRules: IDateRule, portfolioBias: PortfolioBias)
+    EqualWeightingPortfolioConstructionModel(rebalancingFunc: Func[DateTime, Nullable[DateTime]], portfolioBias: PortfolioBias)
+    EqualWeightingPortfolioConstructionModel(rebalancingFunc: Func[DateTime, DateTime], portfolioBias: PortfolioBias)
+    EqualWeightingPortfolioConstructionModel(rebalance: PyObject, portfolioBias: PortfolioBias)
+    EqualWeightingPortfolioConstructionModel(timeSpan: TimeSpan, portfolioBias: PortfolioBias)
+    EqualWeightingPortfolioConstructionModel(resolution: Resolution, portfolioBias: PortfolioBias)
+    """
+    @typing.overload
+    def __init__(self, rebalancingDateRules: QuantConnect.Scheduling.IDateRule, portfolioBias: QuantConnect.Algorithm.Framework.Portfolio.PortfolioBias) -> QuantConnect.Algorithm.Framework.Portfolio.EqualWeightingPortfolioConstructionModel:
+        pass
+
+    @typing.overload
+    def __init__(self, rebalancingFunc: typing.Callable[[datetime.datetime], typing.Optional[datetime.datetime]], portfolioBias: QuantConnect.Algorithm.Framework.Portfolio.PortfolioBias) -> QuantConnect.Algorithm.Framework.Portfolio.EqualWeightingPortfolioConstructionModel:
+        pass
+
+    @typing.overload
+    def __init__(self, rebalancingFunc: typing.Callable[[datetime.datetime], datetime.datetime], portfolioBias: QuantConnect.Algorithm.Framework.Portfolio.PortfolioBias) -> QuantConnect.Algorithm.Framework.Portfolio.EqualWeightingPortfolioConstructionModel:
+        pass
+
+    @typing.overload
+    def __init__(self, rebalance: Python.Runtime.PyObject, portfolioBias: QuantConnect.Algorithm.Framework.Portfolio.PortfolioBias) -> QuantConnect.Algorithm.Framework.Portfolio.EqualWeightingPortfolioConstructionModel:
+        pass
+
+    @typing.overload
+    def __init__(self, timeSpan: datetime.timedelta, portfolioBias: QuantConnect.Algorithm.Framework.Portfolio.PortfolioBias) -> QuantConnect.Algorithm.Framework.Portfolio.EqualWeightingPortfolioConstructionModel:
+        pass
+
+    @typing.overload
+    def __init__(self, resolution: QuantConnect.Resolution, portfolioBias: QuantConnect.Algorithm.Framework.Portfolio.PortfolioBias) -> QuantConnect.Algorithm.Framework.Portfolio.EqualWeightingPortfolioConstructionModel:
+        pass
+
+    def __init__(self, *args) -> QuantConnect.Algorithm.Framework.Portfolio.EqualWeightingPortfolioConstructionModel:
+        pass
+
+    PythonWrapper: QuantConnect.Algorithm.Framework.Portfolio.PortfolioConstructionModelPythonWrapper
+
+
+class InsightWeightingPortfolioConstructionModel(QuantConnect.Algorithm.Framework.Portfolio.EqualWeightingPortfolioConstructionModel, QuantConnect.Algorithm.Framework.INotifiedSecurityChanges, QuantConnect.Algorithm.Framework.Portfolio.IPortfolioConstructionModel):
+    """
+    Provides an implementation of QuantConnect.Algorithm.Framework.Portfolio.IPortfolioConstructionModel that generates percent targets based on the
+                QuantConnect.Algorithm.Framework.Alphas.Insight.Weight. The target percent holdings of each Symbol is given by the QuantConnect.Algorithm.Framework.Alphas.Insight.Weight
+                from the last active QuantConnect.Algorithm.Framework.Alphas.Insight for that symbol.
+                For insights of direction QuantConnect.Algorithm.Framework.Alphas.InsightDirection.Up, long targets are returned and for insights of direction
+                QuantConnect.Algorithm.Framework.Alphas.InsightDirection.Down, short targets are returned.
+                If the sum of all the last active QuantConnect.Algorithm.Framework.Alphas.Insight per symbol is bigger than 1, it will factor down each target
+                percent holdings proportionally so the sum is 1.
+                It will ignore QuantConnect.Algorithm.Framework.Alphas.Insight that have no QuantConnect.Algorithm.Framework.Alphas.Insight.Weight value.
+    
+    InsightWeightingPortfolioConstructionModel(rebalancingDateRules: IDateRule, portfolioBias: PortfolioBias)
+    InsightWeightingPortfolioConstructionModel(rebalance: PyObject, portfolioBias: PortfolioBias)
+    InsightWeightingPortfolioConstructionModel(rebalancingFunc: Func[DateTime, Nullable[DateTime]], portfolioBias: PortfolioBias)
+    InsightWeightingPortfolioConstructionModel(rebalancingFunc: Func[DateTime, DateTime], portfolioBias: PortfolioBias)
+    InsightWeightingPortfolioConstructionModel(timeSpan: TimeSpan, portfolioBias: PortfolioBias)
+    InsightWeightingPortfolioConstructionModel(resolution: Resolution, portfolioBias: PortfolioBias)
+    """
+    @typing.overload
+    def __init__(self, rebalancingDateRules: QuantConnect.Scheduling.IDateRule, portfolioBias: QuantConnect.Algorithm.Framework.Portfolio.PortfolioBias) -> QuantConnect.Algorithm.Framework.Portfolio.InsightWeightingPortfolioConstructionModel:
+        pass
+
+    @typing.overload
+    def __init__(self, rebalance: Python.Runtime.PyObject, portfolioBias: QuantConnect.Algorithm.Framework.Portfolio.PortfolioBias) -> QuantConnect.Algorithm.Framework.Portfolio.InsightWeightingPortfolioConstructionModel:
+        pass
+
+    @typing.overload
+    def __init__(self, rebalancingFunc: typing.Callable[[datetime.datetime], typing.Optional[datetime.datetime]], portfolioBias: QuantConnect.Algorithm.Framework.Portfolio.PortfolioBias) -> QuantConnect.Algorithm.Framework.Portfolio.InsightWeightingPortfolioConstructionModel:
+        pass
+
+    @typing.overload
+    def __init__(self, rebalancingFunc: typing.Callable[[datetime.datetime], datetime.datetime], portfolioBias: QuantConnect.Algorithm.Framework.Portfolio.PortfolioBias) -> QuantConnect.Algorithm.Framework.Portfolio.InsightWeightingPortfolioConstructionModel:
+        pass
+
+    @typing.overload
+    def __init__(self, timeSpan: datetime.timedelta, portfolioBias: QuantConnect.Algorithm.Framework.Portfolio.PortfolioBias) -> QuantConnect.Algorithm.Framework.Portfolio.InsightWeightingPortfolioConstructionModel:
+        pass
+
+    @typing.overload
+    def __init__(self, resolution: QuantConnect.Resolution, portfolioBias: QuantConnect.Algorithm.Framework.Portfolio.PortfolioBias) -> QuantConnect.Algorithm.Framework.Portfolio.InsightWeightingPortfolioConstructionModel:
+        pass
+
+    def __init__(self, *args) -> QuantConnect.Algorithm.Framework.Portfolio.InsightWeightingPortfolioConstructionModel:
+        pass
+
+    PythonWrapper: QuantConnect.Algorithm.Framework.Portfolio.PortfolioConstructionModelPythonWrapper
+
+
+class ConfidenceWeightedPortfolioConstructionModel(QuantConnect.Algorithm.Framework.Portfolio.InsightWeightingPortfolioConstructionModel, QuantConnect.Algorithm.Framework.INotifiedSecurityChanges, QuantConnect.Algorithm.Framework.Portfolio.IPortfolioConstructionModel):
+    """
+    Provides an implementation of QuantConnect.Algorithm.Framework.Portfolio.IPortfolioConstructionModel that generates percent targets based on the
+                QuantConnect.Algorithm.Framework.Alphas.Insight.Confidence. The target percent holdings of each Symbol is given by the QuantConnect.Algorithm.Framework.Alphas.Insight.Confidence
+                from the last active QuantConnect.Algorithm.Framework.Alphas.Insight for that symbol.
+                For insights of direction QuantConnect.Algorithm.Framework.Alphas.InsightDirection.Up, long targets are returned and for insights of direction
+                QuantConnect.Algorithm.Framework.Alphas.InsightDirection.Down, short targets are returned.
+                If the sum of all the last active QuantConnect.Algorithm.Framework.Alphas.Insight per symbol is bigger than 1, it will factor down each target
+                percent holdings proportionally so the sum is 1.
+                It will ignore QuantConnect.Algorithm.Framework.Alphas.Insight that have no QuantConnect.Algorithm.Framework.Alphas.Insight.Confidence value.
+    
+    ConfidenceWeightedPortfolioConstructionModel(rebalancingDateRules: IDateRule, portfolioBias: PortfolioBias)
+    ConfidenceWeightedPortfolioConstructionModel(rebalance: PyObject, portfolioBias: PortfolioBias)
+    ConfidenceWeightedPortfolioConstructionModel(rebalancingFunc: Func[DateTime, Nullable[DateTime]], portfolioBias: PortfolioBias)
+    ConfidenceWeightedPortfolioConstructionModel(rebalancingFunc: Func[DateTime, DateTime], portfolioBias: PortfolioBias)
+    ConfidenceWeightedPortfolioConstructionModel(timeSpan: TimeSpan, portfolioBias: PortfolioBias)
+    ConfidenceWeightedPortfolioConstructionModel(resolution: Resolution, portfolioBias: PortfolioBias)
+    """
+    @typing.overload
+    def __init__(self, rebalancingDateRules: QuantConnect.Scheduling.IDateRule, portfolioBias: QuantConnect.Algorithm.Framework.Portfolio.PortfolioBias) -> QuantConnect.Algorithm.Framework.Portfolio.ConfidenceWeightedPortfolioConstructionModel:
+        pass
+
+    @typing.overload
+    def __init__(self, rebalance: Python.Runtime.PyObject, portfolioBias: QuantConnect.Algorithm.Framework.Portfolio.PortfolioBias) -> QuantConnect.Algorithm.Framework.Portfolio.ConfidenceWeightedPortfolioConstructionModel:
+        pass
+
+    @typing.overload
+    def __init__(self, rebalancingFunc: typing.Callable[[datetime.datetime], typing.Optional[datetime.datetime]], portfolioBias: QuantConnect.Algorithm.Framework.Portfolio.PortfolioBias) -> QuantConnect.Algorithm.Framework.Portfolio.ConfidenceWeightedPortfolioConstructionModel:
+        pass
+
+    @typing.overload
+    def __init__(self, rebalancingFunc: typing.Callable[[datetime.datetime], datetime.datetime], portfolioBias: QuantConnect.Algorithm.Framework.Portfolio.PortfolioBias) -> QuantConnect.Algorithm.Framework.Portfolio.ConfidenceWeightedPortfolioConstructionModel:
+        pass
+
+    @typing.overload
+    def __init__(self, timeSpan: datetime.timedelta, portfolioBias: QuantConnect.Algorithm.Framework.Portfolio.PortfolioBias) -> QuantConnect.Algorithm.Framework.Portfolio.ConfidenceWeightedPortfolioConstructionModel:
+        pass
+
+    @typing.overload
+    def __init__(self, resolution: QuantConnect.Resolution, portfolioBias: QuantConnect.Algorithm.Framework.Portfolio.PortfolioBias) -> QuantConnect.Algorithm.Framework.Portfolio.ConfidenceWeightedPortfolioConstructionModel:
+        pass
+
+    def __init__(self, *args) -> QuantConnect.Algorithm.Framework.Portfolio.ConfidenceWeightedPortfolioConstructionModel:
+        pass
+
+    PythonWrapper: QuantConnect.Algorithm.Framework.Portfolio.PortfolioConstructionModelPythonWrapper

Algorithm.Python/stubs/QuantConnect/Algorithm/Framework/__Portfolio_2.py

@@ -0,0 +1,158 @@
+from .__Portfolio_3 import *
+import typing
+import System.Collections.Generic
+import System
+import QuantConnect.Scheduling
+import QuantConnect.Interfaces
+import QuantConnect.Data.UniverseSelection
+import QuantConnect.Algorithm.Framework.Portfolio
+import QuantConnect.Algorithm.Framework.Alphas
+import QuantConnect.Algorithm
+import QuantConnect
+import Python.Runtime
+import datetime
+
+
+class IPortfolioConstructionModel(QuantConnect.Algorithm.Framework.INotifiedSecurityChanges):
+    """ Algorithm framework model that """
+    def CreateTargets(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, insights: typing.List[QuantConnect.Algorithm.Framework.Alphas.Insight]) -> typing.List[QuantConnect.Algorithm.Framework.Portfolio.IPortfolioTarget]:
+        pass
+
+
+class IPortfolioOptimizer:
+    """ Interface for portfolio optimization algorithms """
+    def Optimize(self, historicalReturns: typing.List[typing.List[float]], expectedReturns: typing.List[float], covariance: typing.List[typing.List[float]]) -> typing.List[float]:
+        pass
+
+
+class IPortfolioTarget:
+    """
+    Represents a portfolio target. This may be a percentage of total portfolio value
+                or it may be a fixed number of shares.
+    """
+    Quantity: float
+
+    Symbol: QuantConnect.Symbol
+
+
+
+class MaximumSharpeRatioPortfolioOptimizer(System.object, QuantConnect.Algorithm.Framework.Portfolio.IPortfolioOptimizer):
+    """
+    Provides an implementation of a portfolio optimizer that maximizes the portfolio Sharpe Ratio.
+                The interval of weights in optimization method can be changed based on the long-short algorithm.
+                The default model uses flat risk free rate and weight for an individual security range from -1 to 1.
+    
+    MaximumSharpeRatioPortfolioOptimizer(lower: float, upper: float, riskFreeRate: float)
+    """
+    def Optimize(self, historicalReturns: typing.List[typing.List[float]], expectedReturns: typing.List[float], covariance: typing.List[typing.List[float]]) -> typing.List[float]:
+        pass
+
+    def __init__(self, lower: float, upper: float, riskFreeRate: float) -> QuantConnect.Algorithm.Framework.Portfolio.MaximumSharpeRatioPortfolioOptimizer:
+        pass
+
+
+class MeanVarianceOptimizationPortfolioConstructionModel(QuantConnect.Algorithm.Framework.Portfolio.PortfolioConstructionModel, QuantConnect.Algorithm.Framework.INotifiedSecurityChanges, QuantConnect.Algorithm.Framework.Portfolio.IPortfolioConstructionModel):
+    """
+    Provides an implementation of Mean-Variance portfolio optimization based on modern portfolio theory.
+                The interval of weights in optimization method can be changed based on the long-short algorithm.
+                The default model uses the last three months daily price to calculate the optimal weight
+                with the weight range from -1 to 1 and minimize the portfolio variance with a target return of 2%
+    
+    MeanVarianceOptimizationPortfolioConstructionModel(rebalancingDateRules: IDateRule, portfolioBias: PortfolioBias, lookback: int, period: int, resolution: Resolution, targetReturn: float, optimizer: IPortfolioOptimizer)
+    MeanVarianceOptimizationPortfolioConstructionModel(rebalanceResolution: Resolution, portfolioBias: PortfolioBias, lookback: int, period: int, resolution: Resolution, targetReturn: float, optimizer: IPortfolioOptimizer)
+    MeanVarianceOptimizationPortfolioConstructionModel(timeSpan: TimeSpan, portfolioBias: PortfolioBias, lookback: int, period: int, resolution: Resolution, targetReturn: float, optimizer: IPortfolioOptimizer)
+    MeanVarianceOptimizationPortfolioConstructionModel(rebalance: PyObject, portfolioBias: PortfolioBias, lookback: int, period: int, resolution: Resolution, targetReturn: float, optimizer: IPortfolioOptimizer)
+    MeanVarianceOptimizationPortfolioConstructionModel(rebalancingFunc: Func[DateTime, DateTime], portfolioBias: PortfolioBias, lookback: int, period: int, resolution: Resolution, targetReturn: float, optimizer: IPortfolioOptimizer)
+    MeanVarianceOptimizationPortfolioConstructionModel(rebalancingFunc: Func[DateTime, Nullable[DateTime]], portfolioBias: PortfolioBias, lookback: int, period: int, resolution: Resolution, targetReturn: float, optimizer: IPortfolioOptimizer)
+    """
+    def OnSecuritiesChanged(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, changes: QuantConnect.Data.UniverseSelection.SecurityChanges) -> None:
+        pass
+
+    @typing.overload
+    def __init__(self, rebalancingDateRules: QuantConnect.Scheduling.IDateRule, portfolioBias: QuantConnect.Algorithm.Framework.Portfolio.PortfolioBias, lookback: int, period: int, resolution: QuantConnect.Resolution, targetReturn: float, optimizer: QuantConnect.Algorithm.Framework.Portfolio.IPortfolioOptimizer) -> QuantConnect.Algorithm.Framework.Portfolio.MeanVarianceOptimizationPortfolioConstructionModel:
+        pass
+
+    @typing.overload
+    def __init__(self, rebalanceResolution: QuantConnect.Resolution, portfolioBias: QuantConnect.Algorithm.Framework.Portfolio.PortfolioBias, lookback: int, period: int, resolution: QuantConnect.Resolution, targetReturn: float, optimizer: QuantConnect.Algorithm.Framework.Portfolio.IPortfolioOptimizer) -> QuantConnect.Algorithm.Framework.Portfolio.MeanVarianceOptimizationPortfolioConstructionModel:
+        pass
+
+    @typing.overload
+    def __init__(self, timeSpan: datetime.timedelta, portfolioBias: QuantConnect.Algorithm.Framework.Portfolio.PortfolioBias, lookback: int, period: int, resolution: QuantConnect.Resolution, targetReturn: float, optimizer: QuantConnect.Algorithm.Framework.Portfolio.IPortfolioOptimizer) -> QuantConnect.Algorithm.Framework.Portfolio.MeanVarianceOptimizationPortfolioConstructionModel:
+        pass
+
+    @typing.overload
+    def __init__(self, rebalance: Python.Runtime.PyObject, portfolioBias: QuantConnect.Algorithm.Framework.Portfolio.PortfolioBias, lookback: int, period: int, resolution: QuantConnect.Resolution, targetReturn: float, optimizer: QuantConnect.Algorithm.Framework.Portfolio.IPortfolioOptimizer) -> QuantConnect.Algorithm.Framework.Portfolio.MeanVarianceOptimizationPortfolioConstructionModel:
+        pass
+
+    @typing.overload
+    def __init__(self, rebalancingFunc: typing.Callable[[datetime.datetime], datetime.datetime], portfolioBias: QuantConnect.Algorithm.Framework.Portfolio.PortfolioBias, lookback: int, period: int, resolution: QuantConnect.Resolution, targetReturn: float, optimizer: QuantConnect.Algorithm.Framework.Portfolio.IPortfolioOptimizer) -> QuantConnect.Algorithm.Framework.Portfolio.MeanVarianceOptimizationPortfolioConstructionModel:
+        pass
+
+    @typing.overload
+    def __init__(self, rebalancingFunc: typing.Callable[[datetime.datetime], typing.Optional[datetime.datetime]], portfolioBias: QuantConnect.Algorithm.Framework.Portfolio.PortfolioBias, lookback: int, period: int, resolution: QuantConnect.Resolution, targetReturn: float, optimizer: QuantConnect.Algorithm.Framework.Portfolio.IPortfolioOptimizer) -> QuantConnect.Algorithm.Framework.Portfolio.MeanVarianceOptimizationPortfolioConstructionModel:
+        pass
+
+    def __init__(self, *args) -> QuantConnect.Algorithm.Framework.Portfolio.MeanVarianceOptimizationPortfolioConstructionModel:
+        pass
+
+    PythonWrapper: QuantConnect.Algorithm.Framework.Portfolio.PortfolioConstructionModelPythonWrapper
+
+
+class MinimumVariancePortfolioOptimizer(System.object, QuantConnect.Algorithm.Framework.Portfolio.IPortfolioOptimizer):
+    """
+    Provides an implementation of a minimum variance portfolio optimizer that calculate the optimal weights
+                with the weight range from -1 to 1 and minimize the portfolio variance with a target return of 2%
+    
+    MinimumVariancePortfolioOptimizer(lower: float, upper: float, targetReturn: float)
+    """
+    def Optimize(self, historicalReturns: typing.List[typing.List[float]], expectedReturns: typing.List[float], covariance: typing.List[typing.List[float]]) -> typing.List[float]:
+        pass
+
+    def __init__(self, lower: float, upper: float, targetReturn: float) -> QuantConnect.Algorithm.Framework.Portfolio.MinimumVariancePortfolioOptimizer:
+        pass
+
+
+class NullPortfolioConstructionModel(QuantConnect.Algorithm.Framework.Portfolio.PortfolioConstructionModel, QuantConnect.Algorithm.Framework.INotifiedSecurityChanges, QuantConnect.Algorithm.Framework.Portfolio.IPortfolioConstructionModel):
+    """
+    Provides an implementation of QuantConnect.Algorithm.Framework.Portfolio.IPortfolioConstructionModel that does nothing
+    
+    NullPortfolioConstructionModel()
+    """
+    def CreateTargets(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, insights: typing.List[QuantConnect.Algorithm.Framework.Alphas.Insight]) -> typing.List[QuantConnect.Algorithm.Framework.Portfolio.IPortfolioTarget]:
+        pass
+
+    PythonWrapper: QuantConnect.Algorithm.Framework.Portfolio.PortfolioConstructionModelPythonWrapper
+
+
+class PortfolioBias(System.Enum, System.IConvertible, System.IFormattable, System.IComparable):
+    """
+    Specifies the bias of the portfolio (Short, Long/Short, Long)
+    
+    enum PortfolioBias, values: Long (1), LongShort (0), Short (-1)
+    """
+    value__: int
+    Long: 'PortfolioBias'
+    LongShort: 'PortfolioBias'
+    Short: 'PortfolioBias'
+
+
+class PortfolioConstructionModelPythonWrapper(QuantConnect.Algorithm.Framework.Portfolio.PortfolioConstructionModel, QuantConnect.Algorithm.Framework.INotifiedSecurityChanges, QuantConnect.Algorithm.Framework.Portfolio.IPortfolioConstructionModel):
+    """
+    Provides an implementation of QuantConnect.Algorithm.Framework.Portfolio.IPortfolioConstructionModel that wraps a Python.Runtime.PyObject object
+    
+    PortfolioConstructionModelPythonWrapper(model: PyObject)
+    """
+    def CreateTargets(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, insights: typing.List[QuantConnect.Algorithm.Framework.Alphas.Insight]) -> typing.List[QuantConnect.Algorithm.Framework.Portfolio.IPortfolioTarget]:
+        pass
+
+    def OnSecuritiesChanged(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, changes: QuantConnect.Data.UniverseSelection.SecurityChanges) -> None:
+        pass
+
+    def __init__(self, model: Python.Runtime.PyObject) -> QuantConnect.Algorithm.Framework.Portfolio.PortfolioConstructionModelPythonWrapper:
+        pass
+
+    RebalanceOnInsightChanges: bool
+
+    RebalanceOnSecurityChanges: bool
+
+    PythonWrapper: QuantConnect.Algorithm.Framework.Portfolio.PortfolioConstructionModelPythonWrapper

Algorithm.Python/stubs/QuantConnect/Algorithm/Framework/__Portfolio_3.py

@@ -0,0 +1,243 @@
+from .__Portfolio_4 import *
+import typing
+import System.Collections.Generic
+import System
+import QuantConnect.Scheduling
+import QuantConnect.Interfaces
+import QuantConnect.Data.UniverseSelection
+import QuantConnect.Algorithm.Framework.Portfolio
+import QuantConnect.Algorithm.Framework.Alphas
+import QuantConnect.Algorithm
+import QuantConnect
+import Python.Runtime
+import datetime
+
+
+class PortfolioTarget(System.object, QuantConnect.Algorithm.Framework.Portfolio.IPortfolioTarget):
+    """
+    Provides an implementation of QuantConnect.Algorithm.Framework.Portfolio.IPortfolioTarget that specifies a
+                specified quantity of a security to be held by the algorithm
+    
+    PortfolioTarget(symbol: Symbol, quantity: Decimal)
+    """
+    @staticmethod
+    @typing.overload
+    def Percent(algorithm: QuantConnect.Interfaces.IAlgorithm, symbol: QuantConnect.Symbol, percent: float) -> QuantConnect.Algorithm.Framework.Portfolio.IPortfolioTarget:
+        pass
+
+    @staticmethod
+    @typing.overload
+    def Percent(algorithm: QuantConnect.Interfaces.IAlgorithm, symbol: QuantConnect.Symbol, percent: float, returnDeltaQuantity: bool) -> QuantConnect.Algorithm.Framework.Portfolio.IPortfolioTarget:
+        pass
+
+    def Percent(self, *args) -> QuantConnect.Algorithm.Framework.Portfolio.IPortfolioTarget:
+        pass
+
+    def ToString(self) -> str:
+        pass
+
+    def __init__(self, symbol: QuantConnect.Symbol, quantity: float) -> QuantConnect.Algorithm.Framework.Portfolio.PortfolioTarget:
+        pass
+
+    Quantity: float
+
+    Symbol: QuantConnect.Symbol
+
+
+
+class PortfolioTargetCollection(System.object, System.Collections.IEnumerable, System.Collections.Generic.ICollection[KeyValuePair[Symbol, IPortfolioTarget]], System.Collections.Generic.ICollection[IPortfolioTarget], System.Collections.Generic.IDictionary[Symbol, IPortfolioTarget], System.Collections.Generic.IEnumerable[KeyValuePair[Symbol, IPortfolioTarget]], System.Collections.Generic.IEnumerable[IPortfolioTarget]):
+    """
+    Provides a collection for managing QuantConnect.Algorithm.Framework.Portfolio.IPortfolioTargets for each symbol
+    
+    PortfolioTargetCollection()
+    """
+    @typing.overload
+    def Add(self, target: QuantConnect.Algorithm.Framework.Portfolio.IPortfolioTarget) -> None:
+        pass
+
+    @typing.overload
+    def Add(self, target: System.Collections.Generic.KeyValuePair[QuantConnect.Symbol, QuantConnect.Algorithm.Framework.Portfolio.IPortfolioTarget]) -> None:
+        pass
+
+    @typing.overload
+    def Add(self, symbol: QuantConnect.Symbol, target: QuantConnect.Algorithm.Framework.Portfolio.IPortfolioTarget) -> None:
+        pass
+
+    def Add(self, *args) -> None:
+        pass
+
+    @typing.overload
+    def AddRange(self, targets: typing.List[QuantConnect.Algorithm.Framework.Portfolio.IPortfolioTarget]) -> None:
+        pass
+
+    @typing.overload
+    def AddRange(self, targets: typing.List[QuantConnect.Algorithm.Framework.Portfolio.IPortfolioTarget]) -> None:
+        pass
+
+    def AddRange(self, *args) -> None:
+        pass
+
+    def Clear(self) -> None:
+        pass
+
+    def ClearFulfilled(self, algorithm: QuantConnect.Interfaces.IAlgorithm) -> None:
+        pass
+
+    @typing.overload
+    def Contains(self, target: QuantConnect.Algorithm.Framework.Portfolio.IPortfolioTarget) -> bool:
+        pass
+
+    @typing.overload
+    def Contains(self, target: System.Collections.Generic.KeyValuePair[QuantConnect.Symbol, QuantConnect.Algorithm.Framework.Portfolio.IPortfolioTarget]) -> bool:
+        pass
+
+    def Contains(self, *args) -> bool:
+        pass
+
+    def ContainsKey(self, symbol: QuantConnect.Symbol) -> bool:
+        pass
+
+    @typing.overload
+    def CopyTo(self, array: typing.List[QuantConnect.Algorithm.Framework.Portfolio.IPortfolioTarget], arrayIndex: int) -> None:
+        pass
+
+    @typing.overload
+    def CopyTo(self, array: typing.List[System.Collections.Generic.KeyValuePair], arrayIndex: int) -> None:
+        pass
+
+    def CopyTo(self, *args) -> None:
+        pass
+
+    def GetEnumerator(self) -> System.Collections.Generic.IEnumerator[QuantConnect.Algorithm.Framework.Portfolio.IPortfolioTarget]:
+        pass
+
+    def OrderByMarginImpact(self, algorithm: QuantConnect.Interfaces.IAlgorithm) -> typing.List[QuantConnect.Algorithm.Framework.Portfolio.IPortfolioTarget]:
+        pass
+
+    @typing.overload
+    def Remove(self, symbol: QuantConnect.Symbol) -> bool:
+        pass
+
+    @typing.overload
+    def Remove(self, target: System.Collections.Generic.KeyValuePair[QuantConnect.Symbol, QuantConnect.Algorithm.Framework.Portfolio.IPortfolioTarget]) -> bool:
+        pass
+
+    @typing.overload
+    def Remove(self, target: QuantConnect.Algorithm.Framework.Portfolio.IPortfolioTarget) -> bool:
+        pass
+
+    def Remove(self, *args) -> bool:
+        pass
+
+    def TryGetValue(self, symbol: QuantConnect.Symbol, target: QuantConnect.Algorithm.Framework.Portfolio.IPortfolioTarget) -> bool:
+        pass
+
+    Count: int
+
+    IsReadOnly: bool
+
+    Keys: typing.List[QuantConnect.Symbol]
+
+    Values: typing.List[QuantConnect.Algorithm.Framework.Portfolio.IPortfolioTarget]
+
+
+    Item: indexer#
+
+
+class ReturnsSymbolData(System.object):
+    """
+    Contains returns specific to a symbol required for optimization model
+    
+    ReturnsSymbolData(symbol: Symbol, lookback: int, period: int)
+    """
+    def Add(self, time: datetime.datetime, value: float) -> None:
+        pass
+
+    def Reset(self) -> None:
+        pass
+
+    def Update(self, time: datetime.datetime, value: float) -> bool:
+        pass
+
+    def __init__(self, symbol: QuantConnect.Symbol, lookback: int, period: int) -> QuantConnect.Algorithm.Framework.Portfolio.ReturnsSymbolData:
+        pass
+
+    Returns: System.Collections.Generic.Dictionary[datetime.datetime, float]
+
+
+
+class ReturnsSymbolDataExtensions(System.object):
+    """ Extension methods for QuantConnect.Algorithm.Framework.Portfolio.ReturnsSymbolData """
+    @staticmethod
+    def FormReturnsMatrix(symbolData: System.Collections.Generic.Dictionary[QuantConnect.Symbol, QuantConnect.Algorithm.Framework.Portfolio.ReturnsSymbolData], symbols: typing.List[QuantConnect.Symbol]) -> typing.List[typing.List[float]]:
+        pass
+
+    __all__: list
+
+
+class SectorWeightingPortfolioConstructionModel(QuantConnect.Algorithm.Framework.Portfolio.EqualWeightingPortfolioConstructionModel, QuantConnect.Algorithm.Framework.INotifiedSecurityChanges, QuantConnect.Algorithm.Framework.Portfolio.IPortfolioConstructionModel):
+    """
+    Provides an implementation of QuantConnect.Algorithm.Framework.Portfolio.IPortfolioConstructionModel that generates percent targets based on the
+                QuantConnect.Data.Fundamental.CompanyReference.IndustryTemplateCode. 
+                The target percent holdings of each sector is 1/S where S is the number of sectors and
+                the target percent holdings of each security is 1/N where N is the number of securities of each sector.
+                For insights of direction QuantConnect.Algorithm.Framework.Alphas.InsightDirection.Up, long targets are returned and for insights of direction
+                QuantConnect.Algorithm.Framework.Alphas.InsightDirection.Down, short targets are returned.
+                It will ignore QuantConnect.Algorithm.Framework.Alphas.Insight for symbols that have no QuantConnect.Data.Fundamental.CompanyReference.IndustryTemplateCode value.
+    
+    SectorWeightingPortfolioConstructionModel(rebalancingDateRules: IDateRule)
+    SectorWeightingPortfolioConstructionModel(rebalancingFunc: Func[DateTime, Nullable[DateTime]])
+    SectorWeightingPortfolioConstructionModel(rebalancingFunc: Func[DateTime, DateTime])
+    SectorWeightingPortfolioConstructionModel(rebalance: PyObject)
+    SectorWeightingPortfolioConstructionModel(timeSpan: TimeSpan)
+    SectorWeightingPortfolioConstructionModel(resolution: Resolution)
+    """
+    def OnSecuritiesChanged(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, changes: QuantConnect.Data.UniverseSelection.SecurityChanges) -> None:
+        pass
+
+    @typing.overload
+    def __init__(self, rebalancingDateRules: QuantConnect.Scheduling.IDateRule) -> QuantConnect.Algorithm.Framework.Portfolio.SectorWeightingPortfolioConstructionModel:
+        pass
+
+    @typing.overload
+    def __init__(self, rebalancingFunc: typing.Callable[[datetime.datetime], typing.Optional[datetime.datetime]]) -> QuantConnect.Algorithm.Framework.Portfolio.SectorWeightingPortfolioConstructionModel:
+        pass
+
+    @typing.overload
+    def __init__(self, rebalancingFunc: typing.Callable[[datetime.datetime], datetime.datetime]) -> QuantConnect.Algorithm.Framework.Portfolio.SectorWeightingPortfolioConstructionModel:
+        pass
+
+    @typing.overload
+    def __init__(self, rebalance: Python.Runtime.PyObject) -> QuantConnect.Algorithm.Framework.Portfolio.SectorWeightingPortfolioConstructionModel:
+        pass
+
+    @typing.overload
+    def __init__(self, timeSpan: datetime.timedelta) -> QuantConnect.Algorithm.Framework.Portfolio.SectorWeightingPortfolioConstructionModel:
+        pass
+
+    @typing.overload
+    def __init__(self, resolution: QuantConnect.Resolution) -> QuantConnect.Algorithm.Framework.Portfolio.SectorWeightingPortfolioConstructionModel:
+        pass
+
+    def __init__(self, *args) -> QuantConnect.Algorithm.Framework.Portfolio.SectorWeightingPortfolioConstructionModel:
+        pass
+
+    PythonWrapper: QuantConnect.Algorithm.Framework.Portfolio.PortfolioConstructionModelPythonWrapper
+
+
+class UnconstrainedMeanVariancePortfolioOptimizer(System.object, QuantConnect.Algorithm.Framework.Portfolio.IPortfolioOptimizer):
+    """
+    Provides an implementation of a portfolio optimizer with unconstrained mean variance.
+    
+    UnconstrainedMeanVariancePortfolioOptimizer()
+    """
+    def Optimize(self, historicalReturns: typing.List[typing.List[float]], expectedReturns: typing.List[float], covariance: typing.List[typing.List[float]]) -> typing.List[float]:
+        pass
+
+# no functions
+# classes
+
+class IPortfolioConstructionModel(QuantConnect.Algorithm.Framework.INotifiedSecurityChanges):
+    """ Algorithm framework model that """
+    def CreateTargets(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, insights: typing.List[QuantConnect.Algorithm.Framework.Alphas.Insight]) -> typing.List[QuantConnect.Algorithm.Framework.Portfolio.IPortfolioTarget]:
+        pass

Algorithm.Python/stubs/QuantConnect/Algorithm/Framework/__Portfolio_4.py

@@ -0,0 +1,58 @@
+import typing
+import System.Collections.Generic
+import System
+import QuantConnect.Scheduling
+import QuantConnect.Interfaces
+import QuantConnect.Data.UniverseSelection
+import QuantConnect.Algorithm.Framework.Portfolio
+import QuantConnect.Algorithm.Framework.Alphas
+import QuantConnect.Algorithm
+import QuantConnect
+import Python.Runtime
+import datetime
+
+
+class PortfolioConstructionModel(System.object, QuantConnect.Algorithm.Framework.INotifiedSecurityChanges, QuantConnect.Algorithm.Framework.Portfolio.IPortfolioConstructionModel):
+    """
+    Provides a base class for portfolio construction models
+    
+    PortfolioConstructionModel(rebalancingFunc: Func[DateTime, Nullable[DateTime]])
+    PortfolioConstructionModel(rebalancingFunc: Func[DateTime, DateTime])
+    """
+    def CreateTargets(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, insights: typing.List[QuantConnect.Algorithm.Framework.Alphas.Insight]) -> typing.List[QuantConnect.Algorithm.Framework.Portfolio.IPortfolioTarget]:
+        pass
+
+    def OnSecuritiesChanged(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, changes: QuantConnect.Data.UniverseSelection.SecurityChanges) -> None:
+        pass
+
+    @typing.overload
+    def __init__(self, rebalancingFunc: typing.Callable[[datetime.datetime], typing.Optional[datetime.datetime]]) -> QuantConnect.Algorithm.Framework.Portfolio.PortfolioConstructionModel:
+        pass
+
+    @typing.overload
+    def __init__(self, rebalancingFunc: typing.Callable[[datetime.datetime], datetime.datetime]) -> QuantConnect.Algorithm.Framework.Portfolio.PortfolioConstructionModel:
+        pass
+
+    def __init__(self, *args) -> QuantConnect.Algorithm.Framework.Portfolio.PortfolioConstructionModel:
+        pass
+
+    RebalanceOnInsightChanges: bool
+
+    RebalanceOnSecurityChanges: bool
+
+    PythonWrapper: QuantConnect.Algorithm.Framework.Portfolio.PortfolioConstructionModelPythonWrapper
+
+
+class MaximumSharpeRatioPortfolioOptimizer(System.object, QuantConnect.Algorithm.Framework.Portfolio.IPortfolioOptimizer):
+    """
+    Provides an implementation of a portfolio optimizer that maximizes the portfolio Sharpe Ratio.
+                The interval of weights in optimization method can be changed based on the long-short algorithm.
+                The default model uses flat risk free rate and weight for an individual security range from -1 to 1.
+    
+    MaximumSharpeRatioPortfolioOptimizer(lower: float, upper: float, riskFreeRate: float)
+    """
+    def Optimize(self, historicalReturns: typing.List[typing.List[float]], expectedReturns: typing.List[float], covariance: typing.List[typing.List[float]]) -> typing.List[float]:
+        pass
+
+    def __init__(self, lower: float, upper: float, riskFreeRate: float) -> QuantConnect.Algorithm.Framework.Portfolio.MaximumSharpeRatioPortfolioOptimizer:
+        pass

Algorithm.Python/stubs/QuantConnect/Algorithm/Framework/__Selection_1.py

@@ -0,0 +1,184 @@
+from .__Selection_2 import *
+import typing
+import System.Collections.Generic
+import System
+import QuantConnect.Securities
+import QuantConnect.Scheduling
+import QuantConnect.Interfaces
+import QuantConnect.Data.UniverseSelection
+import QuantConnect.Data.Fundamental
+import QuantConnect.Data
+import QuantConnect.Algorithm.Framework.Selection
+import QuantConnect.Algorithm
+import QuantConnect
+import Python.Runtime
+import NodaTime
+import datetime
+
+
+class InceptionDateUniverseSelectionModel(QuantConnect.Algorithm.Framework.Selection.CustomUniverseSelectionModel, QuantConnect.Algorithm.Framework.Selection.IUniverseSelectionModel):
+    """
+    Inception Date Universe that accepts a Dictionary of DateTime keyed by String that represent
+                the Inception date for each ticker
+    
+    InceptionDateUniverseSelectionModel(name: str, tickersByDate: Dictionary[str, DateTime])
+    InceptionDateUniverseSelectionModel(name: str, tickersByDate: PyObject)
+    """
+    def Select(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, date: datetime.datetime) -> typing.List[str]:
+        pass
+
+    @typing.overload
+    def __init__(self, name: str, tickersByDate: System.Collections.Generic.Dictionary[str, datetime.datetime]) -> QuantConnect.Algorithm.Framework.Selection.InceptionDateUniverseSelectionModel:
+        pass
+
+    @typing.overload
+    def __init__(self, name: str, tickersByDate: Python.Runtime.PyObject) -> QuantConnect.Algorithm.Framework.Selection.InceptionDateUniverseSelectionModel:
+        pass
+
+    def __init__(self, *args) -> QuantConnect.Algorithm.Framework.Selection.InceptionDateUniverseSelectionModel:
+        pass
+
+
+class EnergyETFUniverse(QuantConnect.Algorithm.Framework.Selection.InceptionDateUniverseSelectionModel, QuantConnect.Algorithm.Framework.Selection.IUniverseSelectionModel):
+    """ EnergyETFUniverse() """
+
+class FineFundamentalUniverseSelectionModel(QuantConnect.Algorithm.Framework.Selection.FundamentalUniverseSelectionModel, QuantConnect.Algorithm.Framework.Selection.IUniverseSelectionModel):
+    """
+    Portfolio selection model that uses coarse/fine selectors. For US equities only.
+    
+    FineFundamentalUniverseSelectionModel(coarseSelector: Func[IEnumerable[CoarseFundamental], IEnumerable[Symbol]], fineSelector: Func[IEnumerable[FineFundamental], IEnumerable[Symbol]], universeSettings: UniverseSettings, securityInitializer: ISecurityInitializer)
+    FineFundamentalUniverseSelectionModel(coarseSelector: PyObject, fineSelector: PyObject, universeSettings: UniverseSettings, securityInitializer: ISecurityInitializer)
+    """
+    def SelectCoarse(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, coarse: typing.List[QuantConnect.Data.UniverseSelection.CoarseFundamental]) -> typing.List[QuantConnect.Symbol]:
+        pass
+
+    def SelectFine(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, fine: typing.List[QuantConnect.Data.Fundamental.FineFundamental]) -> typing.List[QuantConnect.Symbol]:
+        pass
+
+    @typing.overload
+    def __init__(self, coarseSelector: typing.Callable[[typing.List[QuantConnect.Data.UniverseSelection.CoarseFundamental]], typing.List[QuantConnect.Symbol]], fineSelector: typing.Callable[[typing.List[QuantConnect.Data.Fundamental.FineFundamental]], typing.List[QuantConnect.Symbol]], universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings, securityInitializer: QuantConnect.Securities.ISecurityInitializer) -> QuantConnect.Algorithm.Framework.Selection.FineFundamentalUniverseSelectionModel:
+        pass
+
+    @typing.overload
+    def __init__(self, coarseSelector: Python.Runtime.PyObject, fineSelector: Python.Runtime.PyObject, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings, securityInitializer: QuantConnect.Securities.ISecurityInitializer) -> QuantConnect.Algorithm.Framework.Selection.FineFundamentalUniverseSelectionModel:
+        pass
+
+    def __init__(self, *args) -> QuantConnect.Algorithm.Framework.Selection.FineFundamentalUniverseSelectionModel:
+        pass
+
+
+class FutureUniverseSelectionModel(QuantConnect.Algorithm.Framework.Selection.UniverseSelectionModel, QuantConnect.Algorithm.Framework.Selection.IUniverseSelectionModel):
+    """
+    Provides an implementation of QuantConnect.Algorithm.Framework.Selection.IUniverseSelectionModel that subscribes to future chains
+    
+    FutureUniverseSelectionModel(refreshInterval: TimeSpan, futureChainSymbolSelector: Func[DateTime, IEnumerable[Symbol]])
+    FutureUniverseSelectionModel(refreshInterval: TimeSpan, futureChainSymbolSelector: Func[DateTime, IEnumerable[Symbol]], universeSettings: UniverseSettings, securityInitializer: ISecurityInitializer)
+    FutureUniverseSelectionModel(refreshInterval: TimeSpan, futureChainSymbolSelector: Func[DateTime, IEnumerable[Symbol]], universeSettings: UniverseSettings)
+    """
+    def CreateUniverses(self, algorithm: QuantConnect.Algorithm.QCAlgorithm) -> typing.List[QuantConnect.Data.UniverseSelection.Universe]:
+        pass
+
+    def GetNextRefreshTimeUtc(self) -> datetime.datetime:
+        pass
+
+    @typing.overload
+    def __init__(self, refreshInterval: datetime.timedelta, futureChainSymbolSelector: typing.Callable[[datetime.datetime], typing.List[QuantConnect.Symbol]]) -> QuantConnect.Algorithm.Framework.Selection.FutureUniverseSelectionModel:
+        pass
+
+    @typing.overload
+    def __init__(self, refreshInterval: datetime.timedelta, futureChainSymbolSelector: typing.Callable[[datetime.datetime], typing.List[QuantConnect.Symbol]], universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings, securityInitializer: QuantConnect.Securities.ISecurityInitializer) -> QuantConnect.Algorithm.Framework.Selection.FutureUniverseSelectionModel:
+        pass
+
+    @typing.overload
+    def __init__(self, refreshInterval: datetime.timedelta, futureChainSymbolSelector: typing.Callable[[datetime.datetime], typing.List[QuantConnect.Symbol]], universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Algorithm.Framework.Selection.FutureUniverseSelectionModel:
+        pass
+
+    def __init__(self, *args) -> QuantConnect.Algorithm.Framework.Selection.FutureUniverseSelectionModel:
+        pass
+
+
+class IUniverseSelectionModel:
+    """ Algorithm framework model that defines the universes to be used by an algorithm """
+    def CreateUniverses(self, algorithm: QuantConnect.Algorithm.QCAlgorithm) -> typing.List[QuantConnect.Data.UniverseSelection.Universe]:
+        pass
+
+    def GetNextRefreshTimeUtc(self) -> datetime.datetime:
+        pass
+
+
+class LiquidETFUniverse(QuantConnect.Algorithm.Framework.Selection.InceptionDateUniverseSelectionModel, QuantConnect.Algorithm.Framework.Selection.IUniverseSelectionModel):
+    """
+    Universe Selection Model that adds the following ETFs at their inception date
+    
+    LiquidETFUniverse()
+    """
+    Grouping: type
+
+
+class ManualUniverse(QuantConnect.Data.UniverseSelection.UserDefinedUniverse, System.IDisposable, QuantConnect.Data.UniverseSelection.ITimeTriggeredUniverse, System.Collections.Specialized.INotifyCollectionChanged):
+    """
+    Defines a universe as a set of manually set symbols. This differs from QuantConnect.Data.UniverseSelection.UserDefinedUniverse
+                in that these securities were not added via AddSecurity.
+    
+    ManualUniverse(configuration: SubscriptionDataConfig, universeSettings: UniverseSettings, securityInitializer: ISecurityInitializer, symbols: IEnumerable[Symbol])
+    ManualUniverse(configuration: SubscriptionDataConfig, universeSettings: UniverseSettings, symbols: IEnumerable[Symbol])
+    ManualUniverse(configuration: SubscriptionDataConfig, universeSettings: UniverseSettings, symbols: Array[Symbol])
+    """
+    @typing.overload
+    def GetSubscriptionRequests(self, security: QuantConnect.Securities.Security, currentTimeUtc: datetime.datetime, maximumEndTimeUtc: datetime.datetime, subscriptionService: QuantConnect.Interfaces.ISubscriptionDataConfigService) -> typing.List[QuantConnect.Data.UniverseSelection.SubscriptionRequest]:
+        pass
+
+    @typing.overload
+    def GetSubscriptionRequests(self, security: QuantConnect.Securities.Security, currentTimeUtc: datetime.datetime, maximumEndTimeUtc: datetime.datetime) -> typing.List[QuantConnect.Data.UniverseSelection.SubscriptionRequest]:
+        pass
+
+    def GetSubscriptionRequests(self, *args) -> typing.List[QuantConnect.Data.UniverseSelection.SubscriptionRequest]:
+        pass
+
+    @typing.overload
+    def __init__(self, configuration: QuantConnect.Data.SubscriptionDataConfig, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings, securityInitializer: QuantConnect.Securities.ISecurityInitializer, symbols: typing.List[QuantConnect.Symbol]) -> QuantConnect.Algorithm.Framework.Selection.ManualUniverse:
+        pass
+
+    @typing.overload
+    def __init__(self, configuration: QuantConnect.Data.SubscriptionDataConfig, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings, symbols: typing.List[QuantConnect.Symbol]) -> QuantConnect.Algorithm.Framework.Selection.ManualUniverse:
+        pass
+
+    @typing.overload
+    def __init__(self, configuration: QuantConnect.Data.SubscriptionDataConfig, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings, symbols: typing.List[QuantConnect.Symbol]) -> QuantConnect.Algorithm.Framework.Selection.ManualUniverse:
+        pass
+
+    def __init__(self, *args) -> QuantConnect.Algorithm.Framework.Selection.ManualUniverse:
+        pass
+
+
+class ManualUniverseSelectionModel(QuantConnect.Algorithm.Framework.Selection.UniverseSelectionModel, QuantConnect.Algorithm.Framework.Selection.IUniverseSelectionModel):
+    """
+    Provides an implementation of QuantConnect.Algorithm.Framework.Selection.IUniverseSelectionModel that simply
+                subscribes to the specified set of symbols
+    
+    ManualUniverseSelectionModel()
+    ManualUniverseSelectionModel(symbols: IEnumerable[Symbol])
+    ManualUniverseSelectionModel(*symbols: Array[Symbol])
+    ManualUniverseSelectionModel(symbols: IEnumerable[Symbol], universeSettings: UniverseSettings, securityInitializer: ISecurityInitializer)
+    """
+    def CreateUniverses(self, algorithm: QuantConnect.Algorithm.QCAlgorithm) -> typing.List[QuantConnect.Data.UniverseSelection.Universe]:
+        pass
+
+    @typing.overload
+    def __init__(self) -> QuantConnect.Algorithm.Framework.Selection.ManualUniverseSelectionModel:
+        pass
+
+    @typing.overload
+    def __init__(self, symbols: typing.List[QuantConnect.Symbol]) -> QuantConnect.Algorithm.Framework.Selection.ManualUniverseSelectionModel:
+        pass
+
+    @typing.overload
+    def __init__(self, symbols: typing.List[QuantConnect.Symbol]) -> QuantConnect.Algorithm.Framework.Selection.ManualUniverseSelectionModel:
+        pass
+
+    @typing.overload
+    def __init__(self, symbols: typing.List[QuantConnect.Symbol], universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings, securityInitializer: QuantConnect.Securities.ISecurityInitializer) -> QuantConnect.Algorithm.Framework.Selection.ManualUniverseSelectionModel:
+        pass
+
+    def __init__(self, *args) -> QuantConnect.Algorithm.Framework.Selection.ManualUniverseSelectionModel:
+        pass

Algorithm.Python/stubs/QuantConnect/Algorithm/Framework/__Selection_2.py

@@ -0,0 +1,165 @@
+from .__Selection_3 import *
+import typing
+import System.Collections.Generic
+import System
+import QuantConnect.Securities
+import QuantConnect.Scheduling
+import QuantConnect.Interfaces
+import QuantConnect.Data.UniverseSelection
+import QuantConnect.Data.Fundamental
+import QuantConnect.Data
+import QuantConnect.Algorithm.Framework.Selection
+import QuantConnect.Algorithm
+import QuantConnect
+import Python.Runtime
+import NodaTime
+import datetime
+
+
+class MetalsETFUniverse(QuantConnect.Algorithm.Framework.Selection.InceptionDateUniverseSelectionModel, QuantConnect.Algorithm.Framework.Selection.IUniverseSelectionModel):
+    """
+    Universe Selection Model that adds the following Metals ETFs at their inception date
+                2004-11-18   GLD    SPDR Gold Trust
+                2005-01-28   IAU    iShares Gold Trust
+                2006-04-28   SLV    iShares Silver Trust
+                2006-05-22   GDX    VanEck Vectors Gold Miners ETF
+                2008-12-04   AGQ    ProShares Ultra Silver
+                2009-11-11   GDXJ   VanEck Vectors Junior Gold Miners ETF
+                2010-01-08   PPLT   Aberdeen Standard Platinum Shares ETF
+                2010-12-08   NUGT   Direxion Daily Gold Miners Bull 3X Shares
+                2010-12-08   DUST   Direxion Daily Gold Miners Bear 3X Shares
+                2011-10-17   USLV   VelocityShares 3x Long Silver ETN
+                2011-10-17   UGLD   VelocityShares 3x Long Gold ETN
+                2013-10-03   JNUG   Direxion Daily Junior Gold Miners Index Bull 3x Shares
+                2013-10-03   JDST   Direxion Daily Junior Gold Miners Index Bear 3X Shares
+    
+    MetalsETFUniverse()
+    """
+
+class NullUniverseSelectionModel(QuantConnect.Algorithm.Framework.Selection.UniverseSelectionModel, QuantConnect.Algorithm.Framework.Selection.IUniverseSelectionModel):
+    """
+    Provides a null implementation of QuantConnect.Algorithm.Framework.Selection.IUniverseSelectionModel
+    
+    NullUniverseSelectionModel()
+    """
+    def CreateUniverses(self, algorithm: QuantConnect.Algorithm.QCAlgorithm) -> typing.List[QuantConnect.Data.UniverseSelection.Universe]:
+        pass
+
+
+class OpenInterestFutureUniverseSelectionModel(QuantConnect.Algorithm.Framework.Selection.FutureUniverseSelectionModel, QuantConnect.Algorithm.Framework.Selection.IUniverseSelectionModel):
+    """
+    Selects contracts in a futures universe, sorted by open interest.  This allows the selection to identifiy current
+                    active contract.
+    
+    OpenInterestFutureUniverseSelectionModel(algorithm: IAlgorithm, futureChainSymbolSelector: Func[DateTime, IEnumerable[Symbol]], chainContractsLookupLimit: Nullable[int], resultsLimit: Nullable[int])
+    """
+    def FilterByOpenInterest(self, contracts: System.Collections.Generic.IReadOnlyDictionary[QuantConnect.Symbol, QuantConnect.Securities.SecurityExchangeHours]) -> typing.List[QuantConnect.Symbol]:
+        pass
+
+    def __init__(self, algorithm: QuantConnect.Interfaces.IAlgorithm, futureChainSymbolSelector: typing.Callable[[datetime.datetime], typing.List[QuantConnect.Symbol]], chainContractsLookupLimit: typing.Optional[int], resultsLimit: typing.Optional[int]) -> QuantConnect.Algorithm.Framework.Selection.OpenInterestFutureUniverseSelectionModel:
+        pass
+
+
+class OptionUniverseSelectionModel(QuantConnect.Algorithm.Framework.Selection.UniverseSelectionModel, QuantConnect.Algorithm.Framework.Selection.IUniverseSelectionModel):
+    """
+    Provides an implementation of QuantConnect.Algorithm.Framework.Selection.IUniverseSelectionModel that subscribes to option chains
+    
+    OptionUniverseSelectionModel(refreshInterval: TimeSpan, optionChainSymbolSelector: Func[DateTime, IEnumerable[Symbol]])
+    OptionUniverseSelectionModel(refreshInterval: TimeSpan, optionChainSymbolSelector: Func[DateTime, IEnumerable[Symbol]], universeSettings: UniverseSettings, securityInitializer: ISecurityInitializer)
+    OptionUniverseSelectionModel(refreshInterval: TimeSpan, optionChainSymbolSelector: Func[DateTime, IEnumerable[Symbol]], universeSettings: UniverseSettings)
+    """
+    def CreateUniverses(self, algorithm: QuantConnect.Algorithm.QCAlgorithm) -> typing.List[QuantConnect.Data.UniverseSelection.Universe]:
+        pass
+
+    def GetNextRefreshTimeUtc(self) -> datetime.datetime:
+        pass
+
+    @typing.overload
+    def __init__(self, refreshInterval: datetime.timedelta, optionChainSymbolSelector: typing.Callable[[datetime.datetime], typing.List[QuantConnect.Symbol]]) -> QuantConnect.Algorithm.Framework.Selection.OptionUniverseSelectionModel:
+        pass
+
+    @typing.overload
+    def __init__(self, refreshInterval: datetime.timedelta, optionChainSymbolSelector: typing.Callable[[datetime.datetime], typing.List[QuantConnect.Symbol]], universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings, securityInitializer: QuantConnect.Securities.ISecurityInitializer) -> QuantConnect.Algorithm.Framework.Selection.OptionUniverseSelectionModel:
+        pass
+
+    @typing.overload
+    def __init__(self, refreshInterval: datetime.timedelta, optionChainSymbolSelector: typing.Callable[[datetime.datetime], typing.List[QuantConnect.Symbol]], universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Algorithm.Framework.Selection.OptionUniverseSelectionModel:
+        pass
+
+    def __init__(self, *args) -> QuantConnect.Algorithm.Framework.Selection.OptionUniverseSelectionModel:
+        pass
+
+
+class QC500UniverseSelectionModel(QuantConnect.Algorithm.Framework.Selection.FundamentalUniverseSelectionModel, QuantConnect.Algorithm.Framework.Selection.IUniverseSelectionModel):
+    """
+    Defines the QC500 universe as a universe selection model for framework algorithm
+                For details: https://github.com/QuantConnect/Lean/pull/1663
+    
+    QC500UniverseSelectionModel()
+    QC500UniverseSelectionModel(universeSettings: UniverseSettings, securityInitializer: ISecurityInitializer)
+    """
+    def SelectCoarse(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, coarse: typing.List[QuantConnect.Data.UniverseSelection.CoarseFundamental]) -> typing.List[QuantConnect.Symbol]:
+        pass
+
+    def SelectFine(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, fine: typing.List[QuantConnect.Data.Fundamental.FineFundamental]) -> typing.List[QuantConnect.Symbol]:
+        pass
+
+    @typing.overload
+    def __init__(self) -> QuantConnect.Algorithm.Framework.Selection.QC500UniverseSelectionModel:
+        pass
+
+    @typing.overload
+    def __init__(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings, securityInitializer: QuantConnect.Securities.ISecurityInitializer) -> QuantConnect.Algorithm.Framework.Selection.QC500UniverseSelectionModel:
+        pass
+
+    def __init__(self, *args) -> QuantConnect.Algorithm.Framework.Selection.QC500UniverseSelectionModel:
+        pass
+
+
+class ScheduledUniverseSelectionModel(QuantConnect.Algorithm.Framework.Selection.UniverseSelectionModel, QuantConnect.Algorithm.Framework.Selection.IUniverseSelectionModel):
+    """
+    Defines a universe selection model that invokes a selector function on a specific scheduled given by an QuantConnect.Scheduling.IDateRule and an QuantConnect.Scheduling.ITimeRule
+    
+    ScheduledUniverseSelectionModel(dateRule: IDateRule, timeRule: ITimeRule, selector: Func[DateTime, IEnumerable[Symbol]], settings: UniverseSettings, initializer: ISecurityInitializer)
+    ScheduledUniverseSelectionModel(timeZone: DateTimeZone, dateRule: IDateRule, timeRule: ITimeRule, selector: Func[DateTime, IEnumerable[Symbol]], settings: UniverseSettings, initializer: ISecurityInitializer)
+    ScheduledUniverseSelectionModel(dateRule: IDateRule, timeRule: ITimeRule, selector: PyObject, settings: UniverseSettings, initializer: ISecurityInitializer)
+    ScheduledUniverseSelectionModel(timeZone: DateTimeZone, dateRule: IDateRule, timeRule: ITimeRule, selector: PyObject, settings: UniverseSettings, initializer: ISecurityInitializer)
+    """
+    def CreateUniverses(self, algorithm: QuantConnect.Algorithm.QCAlgorithm) -> typing.List[QuantConnect.Data.UniverseSelection.Universe]:
+        pass
+
+    @typing.overload
+    def __init__(self, dateRule: QuantConnect.Scheduling.IDateRule, timeRule: QuantConnect.Scheduling.ITimeRule, selector: typing.Callable[[datetime.datetime], typing.List[QuantConnect.Symbol]], settings: QuantConnect.Data.UniverseSelection.UniverseSettings, initializer: QuantConnect.Securities.ISecurityInitializer) -> QuantConnect.Algorithm.Framework.Selection.ScheduledUniverseSelectionModel:
+        pass
+
+    @typing.overload
+    def __init__(self, timeZone: NodaTime.DateTimeZone, dateRule: QuantConnect.Scheduling.IDateRule, timeRule: QuantConnect.Scheduling.ITimeRule, selector: typing.Callable[[datetime.datetime], typing.List[QuantConnect.Symbol]], settings: QuantConnect.Data.UniverseSelection.UniverseSettings, initializer: QuantConnect.Securities.ISecurityInitializer) -> QuantConnect.Algorithm.Framework.Selection.ScheduledUniverseSelectionModel:
+        pass
+
+    @typing.overload
+    def __init__(self, dateRule: QuantConnect.Scheduling.IDateRule, timeRule: QuantConnect.Scheduling.ITimeRule, selector: Python.Runtime.PyObject, settings: QuantConnect.Data.UniverseSelection.UniverseSettings, initializer: QuantConnect.Securities.ISecurityInitializer) -> QuantConnect.Algorithm.Framework.Selection.ScheduledUniverseSelectionModel:
+        pass
+
+    @typing.overload
+    def __init__(self, timeZone: NodaTime.DateTimeZone, dateRule: QuantConnect.Scheduling.IDateRule, timeRule: QuantConnect.Scheduling.ITimeRule, selector: Python.Runtime.PyObject, settings: QuantConnect.Data.UniverseSelection.UniverseSettings, initializer: QuantConnect.Securities.ISecurityInitializer) -> QuantConnect.Algorithm.Framework.Selection.ScheduledUniverseSelectionModel:
+        pass
+
+    def __init__(self, *args) -> QuantConnect.Algorithm.Framework.Selection.ScheduledUniverseSelectionModel:
+        pass
+
+
+class SP500SectorsETFUniverse(QuantConnect.Algorithm.Framework.Selection.InceptionDateUniverseSelectionModel, QuantConnect.Algorithm.Framework.Selection.IUniverseSelectionModel):
+    """
+    Universe Selection Model that adds the following SP500 Sectors ETFs at their inception date
+                1998-12-22   XLB   Materials Select Sector SPDR ETF
+                1998-12-22   XLE   Energy Select Sector SPDR Fund
+                1998-12-22   XLF   Financial Select Sector SPDR Fund
+                1998-12-22   XLI   Industrial Select Sector SPDR Fund
+                1998-12-22   XLK   Technology Select Sector SPDR Fund
+                1998-12-22   XLP   Consumer Staples Select Sector SPDR Fund
+                1998-12-22   XLU   Utilities Select Sector SPDR Fund
+                1998-12-22   XLV   Health Care Select Sector SPDR Fund
+                1998-12-22   XLY   Consumer Discretionary Select Sector SPDR Fund
+    
+    SP500SectorsETFUniverse()
+    """

Algorithm.Python/stubs/QuantConnect/Algorithm/Framework/__Selection_3.py

@@ -0,0 +1,110 @@
+import typing
+import System.Collections.Generic
+import System
+import QuantConnect.Securities
+import QuantConnect.Scheduling
+import QuantConnect.Interfaces
+import QuantConnect.Data.UniverseSelection
+import QuantConnect.Data.Fundamental
+import QuantConnect.Data
+import QuantConnect.Algorithm.Framework.Selection
+import QuantConnect.Algorithm
+import QuantConnect
+import Python.Runtime
+import NodaTime
+import datetime
+
+class TechnologyETFUniverse(QuantConnect.Algorithm.Framework.Selection.InceptionDateUniverseSelectionModel, QuantConnect.Algorithm.Framework.Selection.IUniverseSelectionModel):
+    """
+    Universe Selection Model that adds the following Technology ETFs at their inception date
+                1998-12-22   XLK    Technology Select Sector SPDR Fund
+                1999-03-10   QQQ    Invesco QQQ
+                2001-07-13   SOXX   iShares PHLX Semiconductor ETF
+                2001-07-13   IGV    iShares Expanded Tech-Software Sector ETF
+                2004-01-30   VGT    Vanguard Information Technology ETF
+                2006-04-25   QTEC   First Trust NASDAQ 100 Technology
+                2006-06-23   FDN    First Trust Dow Jones Internet Index
+                2007-05-10   FXL    First Trust Technology AlphaDEX Fund
+                2008-12-17   TECL   Direxion Daily Technology Bull 3X Shares
+                2008-12-17   TECS   Direxion Daily Technology Bear 3X Shares
+                2010-03-11   SOXL   Direxion Daily Semiconductor Bull 3x Shares
+                2010-03-11   SOXS   Direxion Daily Semiconductor Bear 3x Shares
+                2011-07-06   SKYY   First Trust ISE Cloud Computing Index Fund
+                2011-12-21   SMH    VanEck Vectors Semiconductor ETF
+                2013-08-01   KWEB   KraneShares CSI China Internet ETF
+                2013-10-24   FTEC   Fidelity MSCI Information Technology Index ETF
+    
+    TechnologyETFUniverse()
+    """
+
+class UniverseSelectionModelPythonWrapper(QuantConnect.Algorithm.Framework.Selection.UniverseSelectionModel, QuantConnect.Algorithm.Framework.Selection.IUniverseSelectionModel):
+    """
+    Provides an implementation of QuantConnect.Algorithm.Framework.Selection.IUniverseSelectionModel that wraps a Python.Runtime.PyObject object
+    
+    UniverseSelectionModelPythonWrapper(model: PyObject)
+    """
+    def CreateUniverses(self, algorithm: QuantConnect.Algorithm.QCAlgorithm) -> typing.List[QuantConnect.Data.UniverseSelection.Universe]:
+        pass
+
+    def GetNextRefreshTimeUtc(self) -> datetime.datetime:
+        pass
+
+    def __init__(self, model: Python.Runtime.PyObject) -> QuantConnect.Algorithm.Framework.Selection.UniverseSelectionModelPythonWrapper:
+        pass
+
+
+class USTreasuriesETFUniverse(QuantConnect.Algorithm.Framework.Selection.InceptionDateUniverseSelectionModel, QuantConnect.Algorithm.Framework.Selection.IUniverseSelectionModel):
+    """
+    Universe Selection Model that adds the following US Treasuries ETFs at their inception date
+                2002-07-26   IEF    iShares 7-10 Year Treasury Bond ETF
+                2002-07-26   SHY    iShares 1-3 Year Treasury Bond ETF
+                2002-07-26   TLT    iShares 20+ Year Treasury Bond ETF
+                2007-01-11   SHV    iShares Short Treasury Bond ETF
+                2007-01-11   IEI    iShares 3-7 Year Treasury Bond ETF
+                2007-01-11   TLH    iShares 10-20 Year Treasury Bond ETF
+                2007-12-10   EDV    Vanguard Ext Duration Treasury ETF
+                2007-05-30   BIL    SPDR Barclays 1-3 Month T-Bill ETF
+                2007-05-30   SPTL   SPDR Portfolio Long Term Treasury ETF
+                2008-05-01   TBT    UltraShort Barclays 20+ Year Treasury
+                2009-04-16   TMF    Direxion Daily 20-Year Treasury Bull 3X
+                2009-04-16   TMV    Direxion Daily 20-Year Treasury Bear 3X
+                2009-08-20   TBF    ProShares Short 20+ Year Treasury
+                2009-11-23   VGSH   Vanguard Short-Term Treasury ETF
+                2009-11-23   VGIT   Vanguard Intermediate-Term Treasury ETF
+                2009-11-24   VGLT   Vanguard Long-Term Treasury ETF
+                2010-08-06   SCHO   Schwab Short-Term U.S. Treasury ETF
+                2010-08-06   SCHR   Schwab Intermediate-Term U.S. Treasury ETF
+                2011-12-01   SPTS   SPDR Portfolio Short Term Treasury ETF
+                2012-02-24   GOVT   iShares U.S. Treasury Bond ETF
+    
+    USTreasuriesETFUniverse()
+    """
+
+class VolatilityETFUniverse(QuantConnect.Algorithm.Framework.Selection.InceptionDateUniverseSelectionModel, QuantConnect.Algorithm.Framework.Selection.IUniverseSelectionModel):
+    """ VolatilityETFUniverse() """
+
+
+class NullUniverseSelectionModel(QuantConnect.Algorithm.Framework.Selection.UniverseSelectionModel, QuantConnect.Algorithm.Framework.Selection.IUniverseSelectionModel):
+    """
+    Provides a null implementation of QuantConnect.Algorithm.Framework.Selection.IUniverseSelectionModel
+    
+    NullUniverseSelectionModel()
+    """
+    def CreateUniverses(self, algorithm: QuantConnect.Algorithm.QCAlgorithm) -> typing.List[QuantConnect.Data.UniverseSelection.Universe]:
+        pass
+
+
+class UniverseSelectionModelPythonWrapper(QuantConnect.Algorithm.Framework.Selection.UniverseSelectionModel, QuantConnect.Algorithm.Framework.Selection.IUniverseSelectionModel):
+    """
+    Provides an implementation of QuantConnect.Algorithm.Framework.Selection.IUniverseSelectionModel that wraps a Python.Runtime.PyObject object
+    
+    UniverseSelectionModelPythonWrapper(model: PyObject)
+    """
+    def CreateUniverses(self, algorithm: QuantConnect.Algorithm.QCAlgorithm) -> typing.List[QuantConnect.Data.UniverseSelection.Universe]:
+        pass
+
+    def GetNextRefreshTimeUtc(self) -> datetime.datetime:
+        pass
+
+    def __init__(self, model: Python.Runtime.PyObject) -> QuantConnect.Algorithm.Framework.Selection.UniverseSelectionModelPythonWrapper:
+        pass

Algorithm.Python/stubs/QuantConnect/Algorithm/Framework/__init__.py

@@ -0,0 +1,56 @@
+import typing
+import System.Collections.Generic
+import QuantConnect.Securities
+import QuantConnect.Data.UniverseSelection
+import QuantConnect.Algorithm.Framework
+import QuantConnect.Algorithm
+import QuantConnect
+import datetime
+
+# no functions
+# classes
+
+class INotifiedSecurityChanges:
+    """ Types implementing this interface will be called when the algorithm's set of securities changes """
+    def OnSecuritiesChanged(self, algorithm: QuantConnect.Algorithm.QCAlgorithm, changes: QuantConnect.Data.UniverseSelection.SecurityChanges) -> None:
+        pass
+
+
+class NotifiedSecurityChanges(System.object):
+    """ Provides convenience methods for updating collections in responses to securities changed events """
+    @staticmethod
+    def Update(changes: QuantConnect.Data.UniverseSelection.SecurityChanges, add: typing.Callable[[QuantConnect.Securities.Security], None], remove: typing.Callable[[QuantConnect.Securities.Security], None]) -> None:
+        pass
+
+    @staticmethod
+    @typing.overload
+    def UpdateCollection(securities: typing.List[QuantConnect.Securities.Security], changes: QuantConnect.Data.UniverseSelection.SecurityChanges) -> None:
+        pass
+
+    @staticmethod
+    @typing.overload
+    def UpdateCollection(securities: typing.List[QuantConnect.Algorithm.Framework.TValue], changes: QuantConnect.Data.UniverseSelection.SecurityChanges, valueFactory: typing.Callable[[QuantConnect.Securities.Security], QuantConnect.Algorithm.Framework.TValue]) -> None:
+        pass
+
+    def UpdateCollection(self, *args) -> None:
+        pass
+
+    @staticmethod
+    @typing.overload
+    def UpdateDictionary(dictionary: System.Collections.Generic.IDictionary[QuantConnect.Securities.Security, QuantConnect.Algorithm.Framework.TValue], changes: QuantConnect.Data.UniverseSelection.SecurityChanges, valueFactory: typing.Callable[[QuantConnect.Securities.Security], QuantConnect.Algorithm.Framework.TValue]) -> None:
+        pass
+
+    @staticmethod
+    @typing.overload
+    def UpdateDictionary(dictionary: System.Collections.Generic.IDictionary[QuantConnect.Symbol, QuantConnect.Algorithm.Framework.TValue], changes: QuantConnect.Data.UniverseSelection.SecurityChanges, valueFactory: typing.Callable[[QuantConnect.Securities.Security], QuantConnect.Algorithm.Framework.TValue]) -> None:
+        pass
+
+    @staticmethod
+    @typing.overload
+    def UpdateDictionary(dictionary: System.Collections.Generic.IDictionary[QuantConnect.Algorithm.Framework.TKey, QuantConnect.Algorithm.Framework.TValue], changes: QuantConnect.Data.UniverseSelection.SecurityChanges, keyFactory: typing.Callable[[QuantConnect.Securities.Security], QuantConnect.Algorithm.Framework.TKey], valueFactory: typing.Callable[[QuantConnect.Securities.Security], QuantConnect.Algorithm.Framework.TValue]) -> None:
+        pass
+
+    def UpdateDictionary(self, *args) -> None:
+        pass
+
+    __all__: list

Algorithm.Python/stubs/QuantConnect/Algorithm/____init___1.py

@@ -0,0 +1,265 @@
+from .____init___2 import *
+import typing
+import System.Collections.Generic
+import System.Collections.Concurrent
+import System
+import QuantConnect.Storage
+import QuantConnect.Securities.Option
+import QuantConnect.Securities.Future
+import QuantConnect.Securities.Forex
+import QuantConnect.Securities.Equity
+import QuantConnect.Securities.Crypto
+import QuantConnect.Securities.Cfd
+import QuantConnect.Securities
+import QuantConnect.Scheduling
+import QuantConnect.Python
+import QuantConnect.Orders
+import QuantConnect.Notifications
+import QuantConnect.Interfaces
+import QuantConnect.Indicators.CandlestickPatterns
+import QuantConnect.Indicators
+import QuantConnect.Data.UniverseSelection
+import QuantConnect.Data.Market
+import QuantConnect.Data.Fundamental
+import QuantConnect.Data.Consolidators
+import QuantConnect.Data
+import QuantConnect.Brokerages
+import QuantConnect.Benchmarks
+import QuantConnect.Algorithm.Framework.Selection
+import QuantConnect.Algorithm.Framework.Risk
+import QuantConnect.Algorithm.Framework.Portfolio
+import QuantConnect.Algorithm.Framework.Execution
+import QuantConnect.Algorithm.Framework.Alphas
+import QuantConnect.Algorithm
+import QuantConnect
+import Python.Runtime
+import pandas
+import NodaTime
+import datetime
+
+
+class ConstituentUniverseDefinitions(System.object):
+    """
+    Provides helpers for defining constituent universes based on the Morningstar
+                asset classification QuantConnect.Data.Fundamental.AssetClassification https://www.morningstar.com/
+    
+    ConstituentUniverseDefinitions(algorithm: IAlgorithm)
+    """
+    def AerospaceAndDefense(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def AggressiveGrowth(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def Agriculture(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def AssetManagement(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def Banks(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def BeveragesAlcoholic(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def BeveragesNonAlcoholic(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def Biotechnology(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def BuildingMaterials(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def BusinessServices(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def CapitalMarkets(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def Chemicals(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def ClassicGrowth(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def Conglomerates(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def Construction(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def ConsumerPackagedGoods(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def CreditServices(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def Cyclicals(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def Distressed(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def DiversifiedFinancialServices(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def DrugManufacturers(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def Education(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def FarmAndHeavyConstructionMachinery(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def FixturesAndAppliances(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def ForestProducts(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def HardAsset(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def Hardware(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def HealthcarePlans(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def HealthcareProvidersAndServices(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def HighYield(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def HomebuildingAndConstruction(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def IndustrialDistribution(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def IndustrialProducts(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def Insurance(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def InteractiveMedia(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def LargeCore(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def LargeGrowth(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def LargeValue(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def ManufacturingApparelAndAccessories(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def MediaDiversified(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def MedicalDevicesAndInstruments(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def MedicalDiagnosticsAndResearch(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def MedicalDistribution(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def MetalsAndMining(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def MidCore(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def MidGrowth(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def MidValue(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def OilAndGas(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def OtherEnergySources(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def PackagingAndContainers(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def PersonalServices(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def RealEstate(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def REITs(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def Restaurants(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def RetailCyclical(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def RetailDefensive(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def Semiconductors(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def SlowGrowth(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def SmallCore(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def SmallGrowth(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def SmallValue(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def Software(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def SpeculativeGrowth(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def Steel(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def TelecommunicationServices(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def TobaccoProducts(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def Transportation(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def TravelAndLeisure(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def UtilitiesIndependentPowerProducers(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def UtilitiesRegulated(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def VehiclesAndParts(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def WasteManagement(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings) -> QuantConnect.Data.UniverseSelection.Universe:
+        pass
+
+    def __init__(self, algorithm: QuantConnect.Interfaces.IAlgorithm) -> QuantConnect.Algorithm.ConstituentUniverseDefinitions:
+        pass

Algorithm.Python/stubs/QuantConnect/Algorithm/____init___3.py

@@ -0,0 +1,55 @@
+import typing
+import System.Collections.Generic
+import System.Collections.Concurrent
+import System
+import QuantConnect.Storage
+import QuantConnect.Securities.Option
+import QuantConnect.Securities.Future
+import QuantConnect.Securities.Forex
+import QuantConnect.Securities.Equity
+import QuantConnect.Securities.Crypto
+import QuantConnect.Securities.Cfd
+import QuantConnect.Securities
+import QuantConnect.Scheduling
+import QuantConnect.Python
+import QuantConnect.Orders
+import QuantConnect.Notifications
+import QuantConnect.Interfaces
+import QuantConnect.Indicators.CandlestickPatterns
+import QuantConnect.Indicators
+import QuantConnect.Data.UniverseSelection
+import QuantConnect.Data.Market
+import QuantConnect.Data.Fundamental
+import QuantConnect.Data.Consolidators
+import QuantConnect.Data
+import QuantConnect.Brokerages
+import QuantConnect.Benchmarks
+import QuantConnect.Algorithm.Framework.Selection
+import QuantConnect.Algorithm.Framework.Risk
+import QuantConnect.Algorithm.Framework.Portfolio
+import QuantConnect.Algorithm.Framework.Execution
+import QuantConnect.Algorithm.Framework.Alphas
+import QuantConnect.Algorithm
+import QuantConnect
+import Python.Runtime
+import pandas
+import NodaTime
+import datetime
+
+
+class UniverseDefinitions(System.object):
+    """
+    Provides helpers for defining universes in algorithms
+    
+    UniverseDefinitions(algorithm: QCAlgorithm)
+    """
+    def __init__(self, algorithm: QuantConnect.Algorithm.QCAlgorithm) -> QuantConnect.Algorithm.UniverseDefinitions:
+        pass
+
+    Constituent: QuantConnect.Algorithm.ConstituentUniverseDefinitions
+
+    DollarVolume: QuantConnect.Algorithm.DollarVolumeUniverseDefinitions
+
+    Index: QuantConnect.Algorithm.IndexUniverseDefinitions
+
+    Unchanged: QuantConnect.Data.UniverseSelection.UnchangedUniverse

Algorithm.Python/stubs/QuantConnect/Algorithm/__init__.py

@@ -0,0 +1,233 @@
+from .____init___1 import *
+import typing
+import System.Collections.Generic
+import System.Collections.Concurrent
+import System
+import QuantConnect.Storage
+import QuantConnect.Securities.Option
+import QuantConnect.Securities.Future
+import QuantConnect.Securities.Forex
+import QuantConnect.Securities.Equity
+import QuantConnect.Securities.Crypto
+import QuantConnect.Securities.Cfd
+import QuantConnect.Securities
+import QuantConnect.Scheduling
+import QuantConnect.Python
+import QuantConnect.Orders
+import QuantConnect.Notifications
+import QuantConnect.Interfaces
+import QuantConnect.Indicators.CandlestickPatterns
+import QuantConnect.Indicators
+import QuantConnect.Data.UniverseSelection
+import QuantConnect.Data.Market
+import QuantConnect.Data.Fundamental
+import QuantConnect.Data.Consolidators
+import QuantConnect.Data
+import QuantConnect.Brokerages
+import QuantConnect.Benchmarks
+import QuantConnect.Algorithm.Framework.Selection
+import QuantConnect.Algorithm.Framework.Risk
+import QuantConnect.Algorithm.Framework.Portfolio
+import QuantConnect.Algorithm.Framework.Execution
+import QuantConnect.Algorithm.Framework.Alphas
+import QuantConnect.Algorithm
+import QuantConnect
+import Python.Runtime
+import pandas
+import NodaTime
+import datetime
+
+# no functions
+# classes
+
+class CandlestickPatterns(System.object):
+    """
+    Provides helpers for using candlestick patterns
+    
+    CandlestickPatterns(algorithm: QCAlgorithm)
+    """
+    def AbandonedBaby(self, symbol: QuantConnect.Symbol, penetration: float, resolution: typing.Optional[QuantConnect.Resolution], selector: typing.Callable[[QuantConnect.Data.IBaseData], QuantConnect.Data.Market.IBaseDataBar]) -> QuantConnect.Indicators.CandlestickPatterns.AbandonedBaby:
+        pass
+
+    def AdvanceBlock(self, symbol: QuantConnect.Symbol, resolution: typing.Optional[QuantConnect.Resolution], selector: typing.Callable[[QuantConnect.Data.IBaseData], QuantConnect.Data.Market.IBaseDataBar]) -> QuantConnect.Indicators.CandlestickPatterns.AdvanceBlock:
+        pass
+
+    def BeltHold(self, symbol: QuantConnect.Symbol, resolution: typing.Optional[QuantConnect.Resolution], selector: typing.Callable[[QuantConnect.Data.IBaseData], QuantConnect.Data.Market.IBaseDataBar]) -> QuantConnect.Indicators.CandlestickPatterns.BeltHold:
+        pass
+
+    def Breakaway(self, symbol: QuantConnect.Symbol, resolution: typing.Optional[QuantConnect.Resolution], selector: typing.Callable[[QuantConnect.Data.IBaseData], QuantConnect.Data.Market.IBaseDataBar]) -> QuantConnect.Indicators.CandlestickPatterns.Breakaway:
+        pass
+
+    def ClosingMarubozu(self, symbol: QuantConnect.Symbol, resolution: typing.Optional[QuantConnect.Resolution], selector: typing.Callable[[QuantConnect.Data.IBaseData], QuantConnect.Data.Market.IBaseDataBar]) -> QuantConnect.Indicators.CandlestickPatterns.ClosingMarubozu:
+        pass
+
+    def ConcealedBabySwallow(self, symbol: QuantConnect.Symbol, resolution: typing.Optional[QuantConnect.Resolution], selector: typing.Callable[[QuantConnect.Data.IBaseData], QuantConnect.Data.Market.IBaseDataBar]) -> QuantConnect.Indicators.CandlestickPatterns.ConcealedBabySwallow:
+        pass
+
+    def Counterattack(self, symbol: QuantConnect.Symbol, resolution: typing.Optional[QuantConnect.Resolution], selector: typing.Callable[[QuantConnect.Data.IBaseData], QuantConnect.Data.Market.IBaseDataBar]) -> QuantConnect.Indicators.CandlestickPatterns.Counterattack:
+        pass
+
+    def DarkCloudCover(self, symbol: QuantConnect.Symbol, penetration: float, resolution: typing.Optional[QuantConnect.Resolution], selector: typing.Callable[[QuantConnect.Data.IBaseData], QuantConnect.Data.Market.IBaseDataBar]) -> QuantConnect.Indicators.CandlestickPatterns.DarkCloudCover:
+        pass
+
+    def Doji(self, symbol: QuantConnect.Symbol, resolution: typing.Optional[QuantConnect.Resolution], selector: typing.Callable[[QuantConnect.Data.IBaseData], QuantConnect.Data.Market.IBaseDataBar]) -> QuantConnect.Indicators.CandlestickPatterns.Doji:
+        pass
+
+    def DojiStar(self, symbol: QuantConnect.Symbol, resolution: typing.Optional[QuantConnect.Resolution], selector: typing.Callable[[QuantConnect.Data.IBaseData], QuantConnect.Data.Market.IBaseDataBar]) -> QuantConnect.Indicators.CandlestickPatterns.DojiStar:
+        pass
+
+    def DragonflyDoji(self, symbol: QuantConnect.Symbol, resolution: typing.Optional[QuantConnect.Resolution], selector: typing.Callable[[QuantConnect.Data.IBaseData], QuantConnect.Data.Market.IBaseDataBar]) -> QuantConnect.Indicators.CandlestickPatterns.DragonflyDoji:
+        pass
+
+    def Engulfing(self, symbol: QuantConnect.Symbol, resolution: typing.Optional[QuantConnect.Resolution], selector: typing.Callable[[QuantConnect.Data.IBaseData], QuantConnect.Data.Market.IBaseDataBar]) -> QuantConnect.Indicators.CandlestickPatterns.Engulfing:
+        pass
+
+    def EveningDojiStar(self, symbol: QuantConnect.Symbol, penetration: float, resolution: typing.Optional[QuantConnect.Resolution], selector: typing.Callable[[QuantConnect.Data.IBaseData], QuantConnect.Data.Market.IBaseDataBar]) -> QuantConnect.Indicators.CandlestickPatterns.EveningDojiStar:
+        pass
+
+    def EveningStar(self, symbol: QuantConnect.Symbol, penetration: float, resolution: typing.Optional[QuantConnect.Resolution], selector: typing.Callable[[QuantConnect.Data.IBaseData], QuantConnect.Data.Market.IBaseDataBar]) -> QuantConnect.Indicators.CandlestickPatterns.EveningStar:
+        pass
+
+    def GapSideBySideWhite(self, symbol: QuantConnect.Symbol, resolution: typing.Optional[QuantConnect.Resolution], selector: typing.Callable[[QuantConnect.Data.IBaseData], QuantConnect.Data.Market.IBaseDataBar]) -> QuantConnect.Indicators.CandlestickPatterns.GapSideBySideWhite:
+        pass
+
+    def GravestoneDoji(self, symbol: QuantConnect.Symbol, resolution: typing.Optional[QuantConnect.Resolution], selector: typing.Callable[[QuantConnect.Data.IBaseData], QuantConnect.Data.Market.IBaseDataBar]) -> QuantConnect.Indicators.CandlestickPatterns.GravestoneDoji:
+        pass
+
+    def Hammer(self, symbol: QuantConnect.Symbol, resolution: typing.Optional[QuantConnect.Resolution], selector: typing.Callable[[QuantConnect.Data.IBaseData], QuantConnect.Data.Market.IBaseDataBar]) -> QuantConnect.Indicators.CandlestickPatterns.Hammer:
+        pass
+
+    def HangingMan(self, symbol: QuantConnect.Symbol, resolution: typing.Optional[QuantConnect.Resolution], selector: typing.Callable[[QuantConnect.Data.IBaseData], QuantConnect.Data.Market.IBaseDataBar]) -> QuantConnect.Indicators.CandlestickPatterns.HangingMan:
+        pass
+
+    def Harami(self, symbol: QuantConnect.Symbol, resolution: typing.Optional[QuantConnect.Resolution], selector: typing.Callable[[QuantConnect.Data.IBaseData], QuantConnect.Data.Market.IBaseDataBar]) -> QuantConnect.Indicators.CandlestickPatterns.Harami:
+        pass
+
+    def HaramiCross(self, symbol: QuantConnect.Symbol, resolution: typing.Optional[QuantConnect.Resolution], selector: typing.Callable[[QuantConnect.Data.IBaseData], QuantConnect.Data.Market.IBaseDataBar]) -> QuantConnect.Indicators.CandlestickPatterns.HaramiCross:
+        pass
+
+    def HighWaveCandle(self, symbol: QuantConnect.Symbol, resolution: typing.Optional[QuantConnect.Resolution], selector: typing.Callable[[QuantConnect.Data.IBaseData], QuantConnect.Data.Market.IBaseDataBar]) -> QuantConnect.Indicators.CandlestickPatterns.HighWaveCandle:
+        pass
+
+    def Hikkake(self, symbol: QuantConnect.Symbol, resolution: typing.Optional[QuantConnect.Resolution], selector: typing.Callable[[QuantConnect.Data.IBaseData], QuantConnect.Data.Market.IBaseDataBar]) -> QuantConnect.Indicators.CandlestickPatterns.Hikkake:
+        pass
+
+    def HikkakeModified(self, symbol: QuantConnect.Symbol, resolution: typing.Optional[QuantConnect.Resolution], selector: typing.Callable[[QuantConnect.Data.IBaseData], QuantConnect.Data.Market.IBaseDataBar]) -> QuantConnect.Indicators.CandlestickPatterns.HikkakeModified:
+        pass
+
+    def HomingPigeon(self, symbol: QuantConnect.Symbol, resolution: typing.Optional[QuantConnect.Resolution], selector: typing.Callable[[QuantConnect.Data.IBaseData], QuantConnect.Data.Market.IBaseDataBar]) -> QuantConnect.Indicators.CandlestickPatterns.HomingPigeon:
+        pass
+
+    def IdenticalThreeCrows(self, symbol: QuantConnect.Symbol, resolution: typing.Optional[QuantConnect.Resolution], selector: typing.Callable[[QuantConnect.Data.IBaseData], QuantConnect.Data.Market.IBaseDataBar]) -> QuantConnect.Indicators.CandlestickPatterns.IdenticalThreeCrows:
+        pass
+
+    def InNeck(self, symbol: QuantConnect.Symbol, resolution: typing.Optional[QuantConnect.Resolution], selector: typing.Callable[[QuantConnect.Data.IBaseData], QuantConnect.Data.Market.IBaseDataBar]) -> QuantConnect.Indicators.CandlestickPatterns.InNeck:
+        pass
+
+    def InvertedHammer(self, symbol: QuantConnect.Symbol, resolution: typing.Optional[QuantConnect.Resolution], selector: typing.Callable[[QuantConnect.Data.IBaseData], QuantConnect.Data.Market.IBaseDataBar]) -> QuantConnect.Indicators.CandlestickPatterns.InvertedHammer:
+        pass
+
+    def Kicking(self, symbol: QuantConnect.Symbol, resolution: typing.Optional[QuantConnect.Resolution], selector: typing.Callable[[QuantConnect.Data.IBaseData], QuantConnect.Data.Market.IBaseDataBar]) -> QuantConnect.Indicators.CandlestickPatterns.Kicking:
+        pass
+
+    def KickingByLength(self, symbol: QuantConnect.Symbol, resolution: typing.Optional[QuantConnect.Resolution], selector: typing.Callable[[QuantConnect.Data.IBaseData], QuantConnect.Data.Market.IBaseDataBar]) -> QuantConnect.Indicators.CandlestickPatterns.KickingByLength:
+        pass
+
+    def LadderBottom(self, symbol: QuantConnect.Symbol, resolution: typing.Optional[QuantConnect.Resolution], selector: typing.Callable[[QuantConnect.Data.IBaseData], QuantConnect.Data.Market.IBaseDataBar]) -> QuantConnect.Indicators.CandlestickPatterns.LadderBottom:
+        pass
+
+    def LongLeggedDoji(self, symbol: QuantConnect.Symbol, resolution: typing.Optional[QuantConnect.Resolution], selector: typing.Callable[[QuantConnect.Data.IBaseData], QuantConnect.Data.Market.IBaseDataBar]) -> QuantConnect.Indicators.CandlestickPatterns.LongLeggedDoji:
+        pass
+
+    def LongLineCandle(self, symbol: QuantConnect.Symbol, resolution: typing.Optional[QuantConnect.Resolution], selector: typing.Callable[[QuantConnect.Data.IBaseData], QuantConnect.Data.Market.IBaseDataBar]) -> QuantConnect.Indicators.CandlestickPatterns.LongLineCandle:
+        pass
+
+    def Marubozu(self, symbol: QuantConnect.Symbol, resolution: typing.Optional[QuantConnect.Resolution], selector: typing.Callable[[QuantConnect.Data.IBaseData], QuantConnect.Data.Market.IBaseDataBar]) -> QuantConnect.Indicators.CandlestickPatterns.Marubozu:
+        pass
+
+    def MatchingLow(self, symbol: QuantConnect.Symbol, resolution: typing.Optional[QuantConnect.Resolution], selector: typing.Callable[[QuantConnect.Data.IBaseData], QuantConnect.Data.Market.IBaseDataBar]) -> QuantConnect.Indicators.CandlestickPatterns.MatchingLow:
+        pass
+
+    def MatHold(self, symbol: QuantConnect.Symbol, penetration: float, resolution: typing.Optional[QuantConnect.Resolution], selector: typing.Callable[[QuantConnect.Data.IBaseData], QuantConnect.Data.Market.IBaseDataBar]) -> QuantConnect.Indicators.CandlestickPatterns.MatHold:
+        pass
+
+    def MorningDojiStar(self, symbol: QuantConnect.Symbol, penetration: float, resolution: typing.Optional[QuantConnect.Resolution], selector: typing.Callable[[QuantConnect.Data.IBaseData], QuantConnect.Data.Market.IBaseDataBar]) -> QuantConnect.Indicators.CandlestickPatterns.MorningDojiStar:
+        pass
+
+    def MorningStar(self, symbol: QuantConnect.Symbol, penetration: float, resolution: typing.Optional[QuantConnect.Resolution], selector: typing.Callable[[QuantConnect.Data.IBaseData], QuantConnect.Data.Market.IBaseDataBar]) -> QuantConnect.Indicators.CandlestickPatterns.MorningStar:
+        pass
+
+    def OnNeck(self, symbol: QuantConnect.Symbol, resolution: typing.Optional[QuantConnect.Resolution], selector: typing.Callable[[QuantConnect.Data.IBaseData], QuantConnect.Data.Market.IBaseDataBar]) -> QuantConnect.Indicators.CandlestickPatterns.OnNeck:
+        pass
+
+    def Piercing(self, symbol: QuantConnect.Symbol, resolution: typing.Optional[QuantConnect.Resolution], selector: typing.Callable[[QuantConnect.Data.IBaseData], QuantConnect.Data.Market.IBaseDataBar]) -> QuantConnect.Indicators.CandlestickPatterns.Piercing:
+        pass
+
+    def RickshawMan(self, symbol: QuantConnect.Symbol, resolution: typing.Optional[QuantConnect.Resolution], selector: typing.Callable[[QuantConnect.Data.IBaseData], QuantConnect.Data.Market.IBaseDataBar]) -> QuantConnect.Indicators.CandlestickPatterns.RickshawMan:
+        pass
+
+    def RiseFallThreeMethods(self, symbol: QuantConnect.Symbol, resolution: typing.Optional[QuantConnect.Resolution], selector: typing.Callable[[QuantConnect.Data.IBaseData], QuantConnect.Data.Market.IBaseDataBar]) -> QuantConnect.Indicators.CandlestickPatterns.RiseFallThreeMethods:
+        pass
+
+    def SeparatingLines(self, symbol: QuantConnect.Symbol, resolution: typing.Optional[QuantConnect.Resolution], selector: typing.Callable[[QuantConnect.Data.IBaseData], QuantConnect.Data.Market.IBaseDataBar]) -> QuantConnect.Indicators.CandlestickPatterns.SeparatingLines:
+        pass
+
+    def ShootingStar(self, symbol: QuantConnect.Symbol, resolution: typing.Optional[QuantConnect.Resolution], selector: typing.Callable[[QuantConnect.Data.IBaseData], QuantConnect.Data.Market.IBaseDataBar]) -> QuantConnect.Indicators.CandlestickPatterns.ShootingStar:
+        pass
+
+    def ShortLineCandle(self, symbol: QuantConnect.Symbol, resolution: typing.Optional[QuantConnect.Resolution], selector: typing.Callable[[QuantConnect.Data.IBaseData], QuantConnect.Data.Market.IBaseDataBar]) -> QuantConnect.Indicators.CandlestickPatterns.ShortLineCandle:
+        pass
+
+    def SpinningTop(self, symbol: QuantConnect.Symbol, resolution: typing.Optional[QuantConnect.Resolution], selector: typing.Callable[[QuantConnect.Data.IBaseData], QuantConnect.Data.Market.IBaseDataBar]) -> QuantConnect.Indicators.CandlestickPatterns.SpinningTop:
+        pass
+
+    def StalledPattern(self, symbol: QuantConnect.Symbol, resolution: typing.Optional[QuantConnect.Resolution], selector: typing.Callable[[QuantConnect.Data.IBaseData], QuantConnect.Data.Market.IBaseDataBar]) -> QuantConnect.Indicators.CandlestickPatterns.StalledPattern:
+        pass
+
+    def StickSandwich(self, symbol: QuantConnect.Symbol, resolution: typing.Optional[QuantConnect.Resolution], selector: typing.Callable[[QuantConnect.Data.IBaseData], QuantConnect.Data.Market.IBaseDataBar]) -> QuantConnect.Indicators.CandlestickPatterns.StickSandwich:
+        pass
+
+    def Takuri(self, symbol: QuantConnect.Symbol, resolution: typing.Optional[QuantConnect.Resolution], selector: typing.Callable[[QuantConnect.Data.IBaseData], QuantConnect.Data.Market.IBaseDataBar]) -> QuantConnect.Indicators.CandlestickPatterns.Takuri:
+        pass
+
+    def TasukiGap(self, symbol: QuantConnect.Symbol, resolution: typing.Optional[QuantConnect.Resolution], selector: typing.Callable[[QuantConnect.Data.IBaseData], QuantConnect.Data.Market.IBaseDataBar]) -> QuantConnect.Indicators.CandlestickPatterns.TasukiGap:
+        pass
+
+    def ThreeBlackCrows(self, symbol: QuantConnect.Symbol, resolution: typing.Optional[QuantConnect.Resolution], selector: typing.Callable[[QuantConnect.Data.IBaseData], QuantConnect.Data.Market.IBaseDataBar]) -> QuantConnect.Indicators.CandlestickPatterns.ThreeBlackCrows:
+        pass
+
+    def ThreeInside(self, symbol: QuantConnect.Symbol, resolution: typing.Optional[QuantConnect.Resolution], selector: typing.Callable[[QuantConnect.Data.IBaseData], QuantConnect.Data.Market.IBaseDataBar]) -> QuantConnect.Indicators.CandlestickPatterns.ThreeInside:
+        pass
+
+    def ThreeLineStrike(self, symbol: QuantConnect.Symbol, resolution: typing.Optional[QuantConnect.Resolution], selector: typing.Callable[[QuantConnect.Data.IBaseData], QuantConnect.Data.Market.IBaseDataBar]) -> QuantConnect.Indicators.CandlestickPatterns.ThreeLineStrike:
+        pass
+
+    def ThreeOutside(self, symbol: QuantConnect.Symbol, resolution: typing.Optional[QuantConnect.Resolution], selector: typing.Callable[[QuantConnect.Data.IBaseData], QuantConnect.Data.Market.IBaseDataBar]) -> QuantConnect.Indicators.CandlestickPatterns.ThreeOutside:
+        pass
+
+    def ThreeStarsInSouth(self, symbol: QuantConnect.Symbol, resolution: typing.Optional[QuantConnect.Resolution], selector: typing.Callable[[QuantConnect.Data.IBaseData], QuantConnect.Data.Market.IBaseDataBar]) -> QuantConnect.Indicators.CandlestickPatterns.ThreeStarsInSouth:
+        pass
+
+    def ThreeWhiteSoldiers(self, symbol: QuantConnect.Symbol, resolution: typing.Optional[QuantConnect.Resolution], selector: typing.Callable[[QuantConnect.Data.IBaseData], QuantConnect.Data.Market.IBaseDataBar]) -> QuantConnect.Indicators.CandlestickPatterns.ThreeWhiteSoldiers:
+        pass
+
+    def Thrusting(self, symbol: QuantConnect.Symbol, resolution: typing.Optional[QuantConnect.Resolution], selector: typing.Callable[[QuantConnect.Data.IBaseData], QuantConnect.Data.Market.IBaseDataBar]) -> QuantConnect.Indicators.CandlestickPatterns.Thrusting:
+        pass
+
+    def Tristar(self, symbol: QuantConnect.Symbol, resolution: typing.Optional[QuantConnect.Resolution], selector: typing.Callable[[QuantConnect.Data.IBaseData], QuantConnect.Data.Market.IBaseDataBar]) -> QuantConnect.Indicators.CandlestickPatterns.Tristar:
+        pass
+
+    def TwoCrows(self, symbol: QuantConnect.Symbol, resolution: typing.Optional[QuantConnect.Resolution], selector: typing.Callable[[QuantConnect.Data.IBaseData], QuantConnect.Data.Market.IBaseDataBar]) -> QuantConnect.Indicators.CandlestickPatterns.TwoCrows:
+        pass
+
+    def UniqueThreeRiver(self, symbol: QuantConnect.Symbol, resolution: typing.Optional[QuantConnect.Resolution], selector: typing.Callable[[QuantConnect.Data.IBaseData], QuantConnect.Data.Market.IBaseDataBar]) -> QuantConnect.Indicators.CandlestickPatterns.UniqueThreeRiver:
+        pass
+
+    def UpDownGapThreeMethods(self, symbol: QuantConnect.Symbol, resolution: typing.Optional[QuantConnect.Resolution], selector: typing.Callable[[QuantConnect.Data.IBaseData], QuantConnect.Data.Market.IBaseDataBar]) -> QuantConnect.Indicators.CandlestickPatterns.UpDownGapThreeMethods:
+        pass
+
+    def UpsideGapTwoCrows(self, symbol: QuantConnect.Symbol, resolution: typing.Optional[QuantConnect.Resolution], selector: typing.Callable[[QuantConnect.Data.IBaseData], QuantConnect.Data.Market.IBaseDataBar]) -> QuantConnect.Indicators.CandlestickPatterns.UpsideGapTwoCrows:
+        pass
+
+    def __init__(self, algorithm: QuantConnect.Algorithm.QCAlgorithm) -> QuantConnect.Algorithm.CandlestickPatterns:
+        pass

Algorithm.Python/stubs/QuantConnect/Api.py

@@ -0,0 +1,139 @@
+# encoding: utf-8
+# module QuantConnect.Api calls itself Api
+# from QuantConnect.Common, Version=2.4.0.0, Culture=neutral, PublicKeyToken=null
+# by generator 1.145
+# no doc
+
+# imports
+import datetime
+import QuantConnect
+import QuantConnect.Api
+import QuantConnect.Packets
+import System
+import typing
+
+# no functions
+# classes
+
+class RestResponse(System.object):
+    """
+    Base API response class for the QuantConnect API.
+    
+    RestResponse()
+    """
+    Errors: typing.List[str]
+    Success: bool
+
+class AuthenticationResponse(QuantConnect.Api.RestResponse):
+    """
+    Verify if the credentials are OK.
+    
+    AuthenticationResponse()
+    """
+
+class Backtest(QuantConnect.Api.RestResponse):
+    """
+    Backtest response packet from the QuantConnect.com API.
+    
+    Backtest()
+    """
+    BacktestId: str
+    Completed: bool
+    Created: datetime.datetime
+    Error: str
+    Name: str
+    Note: str
+    Progress: float
+    Result: QuantConnect.Packets.BacktestResult
+    StackTrace: str
+
+class BacktestList(QuantConnect.Api.RestResponse):
+    """
+    Collection container for a list of backtests for a project
+    
+    BacktestList()
+    """
+    Backtests: typing.List[QuantConnect.Api.Backtest]
+
+class BacktestReport(QuantConnect.Api.RestResponse):
+    """
+    Backtest Report Response wrapper
+    
+    BacktestReport()
+    """
+    Report: str
+
+
+
+class Compile(QuantConnect.Api.RestResponse):
+    """
+    Response from the compiler on a build event
+    
+    Compile()
+    """
+    CompileId: str
+    Logs: typing.List[str]
+    State: QuantConnect.Api.CompileState
+
+class CompileState(System.Enum, System.IConvertible, System.IFormattable, System.IComparable):
+    """
+    State of the compilation request
+    
+    enum CompileState, values: BuildError (2), BuildSuccess (1), InQueue (0)
+    """
+    value__: int
+    BuildError: 'CompileState'
+    BuildSuccess: 'CompileState'
+    InQueue: 'CompileState'
+
+
+class Link(QuantConnect.Api.RestResponse):
+    """
+    Response from reading purchased data
+    
+    Link()
+    """
+    DataLink: str
+
+
+
+class Project(QuantConnect.Api.RestResponse):
+    """
+    Response from reading a project by id.
+    
+    Project()
+    """
+    Created: datetime.datetime
+    Language: QuantConnect.Language
+    Modified: datetime.datetime
+    Name: str
+    ProjectId: int
+
+class ProjectFile(System.object):
+    """
+    File for a project
+    
+    ProjectFile()
+    """
+    DateModified: datetime.datetime
+
+    Code: str
+    Name: str
+
+
+class ProjectFilesResponse(QuantConnect.Api.RestResponse):
+    """
+    Response received when reading all files of a project
+    
+    ProjectFilesResponse()
+    """
+    Files: typing.List[QuantConnect.Api.ProjectFile]
+
+class ProjectResponse(QuantConnect.Api.RestResponse):
+    """
+    Project list response
+    
+    ProjectResponse()
+    """
+    Projects: typing.List[QuantConnect.Api.Project]
+

Algorithm.Python/stubs/QuantConnect/Benchmarks.py

@@ -0,0 +1,51 @@
+# encoding: utf-8
+# module QuantConnect.Benchmarks calls itself Benchmarks
+# from QuantConnect.Common, Version=2.4.0.0, Culture=neutral, PublicKeyToken=null
+# by generator 1.145
+# no doc
+
+# imports
+import datetime
+import QuantConnect.Benchmarks
+import QuantConnect.Securities
+import System
+import typing
+
+# no functions
+# classes
+
+class FuncBenchmark(System.object, QuantConnect.Benchmarks.IBenchmark):
+    """
+    Creates a benchmark defined by a function
+    
+    FuncBenchmark(benchmark: Func[DateTime, Decimal])
+    """
+    def Evaluate(self, time: datetime.datetime) -> float:
+        pass
+
+    def __init__(self, benchmark: typing.Callable[[datetime.datetime], float]) -> QuantConnect.Benchmarks.FuncBenchmark:
+        pass
+
+
+class IBenchmark:
+    """ Specifies how to compute a benchmark for an algorithm """
+    def Evaluate(self, time: datetime.datetime) -> float:
+        pass
+
+
+class SecurityBenchmark(System.object, QuantConnect.Benchmarks.IBenchmark):
+    """
+    Creates a benchmark defined by the closing price of a QuantConnect.Benchmarks.SecurityBenchmark.Security instance
+    
+    SecurityBenchmark(security: Security)
+    """
+    def Evaluate(self, time: datetime.datetime) -> float:
+        pass
+
+    def __init__(self, security: QuantConnect.Securities.Security) -> QuantConnect.Benchmarks.SecurityBenchmark:
+        pass
+
+    Security: QuantConnect.Securities.Security
+
+
+

Algorithm.Python/stubs/QuantConnect/Brokerages.py

@@ -0,0 +1,279 @@
+from .__Brokerages_1 import *
+import typing
+import System.Collections.Generic
+import System
+import QuantConnect.Securities
+import QuantConnect.Packets
+import QuantConnect.Orders.Slippage
+import QuantConnect.Orders.Fills
+import QuantConnect.Orders.Fees
+import QuantConnect.Orders
+import QuantConnect.Interfaces
+import QuantConnect.Data.Market
+import QuantConnect.Brokerages
+import QuantConnect
+import datetime
+
+# no functions
+# classes
+
+class DefaultBrokerageModel(System.object, QuantConnect.Brokerages.IBrokerageModel):
+    """
+    Provides a default implementation of QuantConnect.Brokerages.IBrokerageModel that allows all orders and uses
+                the default transaction models
+    
+    DefaultBrokerageModel(accountType: AccountType)
+    """
+    def ApplySplit(self, tickets: typing.List[QuantConnect.Orders.OrderTicket], split: QuantConnect.Data.Market.Split) -> None:
+        pass
+
+    def CanExecuteOrder(self, security: QuantConnect.Securities.Security, order: QuantConnect.Orders.Order) -> bool:
+        pass
+
+    def CanSubmitOrder(self, security: QuantConnect.Securities.Security, order: QuantConnect.Orders.Order, message: QuantConnect.Brokerages.BrokerageMessageEvent) -> bool:
+        pass
+
+    def CanUpdateOrder(self, security: QuantConnect.Securities.Security, order: QuantConnect.Orders.Order, request: QuantConnect.Orders.UpdateOrderRequest, message: QuantConnect.Brokerages.BrokerageMessageEvent) -> bool:
+        pass
+
+    @typing.overload
+    def GetBuyingPowerModel(self, security: QuantConnect.Securities.Security) -> QuantConnect.Securities.IBuyingPowerModel:
+        pass
+
+    @typing.overload
+    def GetBuyingPowerModel(self, security: QuantConnect.Securities.Security, accountType: QuantConnect.AccountType) -> QuantConnect.Securities.IBuyingPowerModel:
+        pass
+
+    def GetBuyingPowerModel(self, *args) -> QuantConnect.Securities.IBuyingPowerModel:
+        pass
+
+    def GetFeeModel(self, security: QuantConnect.Securities.Security) -> QuantConnect.Orders.Fees.IFeeModel:
+        pass
+
+    def GetFillModel(self, security: QuantConnect.Securities.Security) -> QuantConnect.Orders.Fills.IFillModel:
+        pass
+
+    def GetLeverage(self, security: QuantConnect.Securities.Security) -> float:
+        pass
+
+    @typing.overload
+    def GetSettlementModel(self, security: QuantConnect.Securities.Security) -> QuantConnect.Securities.ISettlementModel:
+        pass
+
+    @typing.overload
+    def GetSettlementModel(self, security: QuantConnect.Securities.Security, accountType: QuantConnect.AccountType) -> QuantConnect.Securities.ISettlementModel:
+        pass
+
+    def GetSettlementModel(self, *args) -> QuantConnect.Securities.ISettlementModel:
+        pass
+
+    def GetSlippageModel(self, security: QuantConnect.Securities.Security) -> QuantConnect.Orders.Slippage.ISlippageModel:
+        pass
+
+    def __init__(self, accountType: QuantConnect.AccountType) -> QuantConnect.Brokerages.DefaultBrokerageModel:
+        pass
+
+    AccountType: QuantConnect.AccountType
+
+    DefaultMarkets: System.Collections.Generic.IReadOnlyDictionary[QuantConnect.SecurityType, str]
+
+    RequiredFreeBuyingPowerPercent: float
+
+
+    DefaultMarketMap: ReadOnlyDictionary[SecurityType, str]
+
+
+class AlpacaBrokerageModel(QuantConnect.Brokerages.DefaultBrokerageModel, QuantConnect.Brokerages.IBrokerageModel):
+    """
+    Alpaca Brokerage Model Implementation for Back Testing.
+    
+    AlpacaBrokerageModel(orderProvider: IOrderProvider, accountType: AccountType)
+    """
+    def CanSubmitOrder(self, security: QuantConnect.Securities.Security, order: QuantConnect.Orders.Order, message: QuantConnect.Brokerages.BrokerageMessageEvent) -> bool:
+        pass
+
+    def GetFeeModel(self, security: QuantConnect.Securities.Security) -> QuantConnect.Orders.Fees.IFeeModel:
+        pass
+
+    def GetFillModel(self, security: QuantConnect.Securities.Security) -> QuantConnect.Orders.Fills.IFillModel:
+        pass
+
+    def GetSlippageModel(self, security: QuantConnect.Securities.Security) -> QuantConnect.Orders.Slippage.ISlippageModel:
+        pass
+
+    def __init__(self, orderProvider: QuantConnect.Securities.IOrderProvider, accountType: QuantConnect.AccountType) -> QuantConnect.Brokerages.AlpacaBrokerageModel:
+        pass
+
+    DefaultMarkets: System.Collections.Generic.IReadOnlyDictionary[QuantConnect.SecurityType, str]
+
+
+    DefaultMarketMap: ReadOnlyDictionary[SecurityType, str]
+
+
+class AlphaStreamsBrokerageModel(QuantConnect.Brokerages.DefaultBrokerageModel, QuantConnect.Brokerages.IBrokerageModel):
+    """
+    Provides properties specific to Alpha Streams
+    
+    AlphaStreamsBrokerageModel(accountType: AccountType)
+    """
+    def GetFeeModel(self, security: QuantConnect.Securities.Security) -> QuantConnect.Orders.Fees.IFeeModel:
+        pass
+
+    def GetLeverage(self, security: QuantConnect.Securities.Security) -> float:
+        pass
+
+    @typing.overload
+    def GetSettlementModel(self, security: QuantConnect.Securities.Security) -> QuantConnect.Securities.ISettlementModel:
+        pass
+
+    @typing.overload
+    def GetSettlementModel(self, security: QuantConnect.Securities.Security, accountType: QuantConnect.AccountType) -> QuantConnect.Securities.ISettlementModel:
+        pass
+
+    def GetSettlementModel(self, *args) -> QuantConnect.Securities.ISettlementModel:
+        pass
+
+    def GetSlippageModel(self, security: QuantConnect.Securities.Security) -> QuantConnect.Orders.Slippage.ISlippageModel:
+        pass
+
+    def __init__(self, accountType: QuantConnect.AccountType) -> QuantConnect.Brokerages.AlphaStreamsBrokerageModel:
+        pass
+
+
+class BitfinexBrokerageModel(QuantConnect.Brokerages.DefaultBrokerageModel, QuantConnect.Brokerages.IBrokerageModel):
+    """
+    Provides Bitfinex specific properties
+    
+    BitfinexBrokerageModel(accountType: AccountType)
+    """
+    @typing.overload
+    def GetBuyingPowerModel(self, security: QuantConnect.Securities.Security) -> QuantConnect.Securities.IBuyingPowerModel:
+        pass
+
+    @typing.overload
+    def GetBuyingPowerModel(self, security: QuantConnect.Securities.Security, accountType: QuantConnect.AccountType) -> QuantConnect.Securities.IBuyingPowerModel:
+        pass
+
+    def GetBuyingPowerModel(self, *args) -> QuantConnect.Securities.IBuyingPowerModel:
+        pass
+
+    def GetFeeModel(self, security: QuantConnect.Securities.Security) -> QuantConnect.Orders.Fees.IFeeModel:
+        pass
+
+    def GetLeverage(self, security: QuantConnect.Securities.Security) -> float:
+        pass
+
+    def __init__(self, accountType: QuantConnect.AccountType) -> QuantConnect.Brokerages.BitfinexBrokerageModel:
+        pass
+
+    DefaultMarkets: System.Collections.Generic.IReadOnlyDictionary[QuantConnect.SecurityType, str]
+
+
+
+class BrokerageFactoryAttribute(System.Attribute, System.Runtime.InteropServices._Attribute):
+    """
+    Represents the brokerage factory type required to load a data queue handler
+    
+    BrokerageFactoryAttribute(type: Type)
+    """
+    def __init__(self, type: type) -> QuantConnect.Brokerages.BrokerageFactoryAttribute:
+        pass
+
+    Type: type
+
+
+
+class BrokerageMessageEvent(System.object):
+    """
+    Represents a message received from a brokerage
+    
+    BrokerageMessageEvent(type: BrokerageMessageType, code: int, message: str)
+    BrokerageMessageEvent(type: BrokerageMessageType, code: str, message: str)
+    """
+    @staticmethod
+    def Disconnected(message: str) -> QuantConnect.Brokerages.BrokerageMessageEvent:
+        pass
+
+    @staticmethod
+    def Reconnected(message: str) -> QuantConnect.Brokerages.BrokerageMessageEvent:
+        pass
+
+    def ToString(self) -> str:
+        pass
+
+    @typing.overload
+    def __init__(self, type: QuantConnect.Brokerages.BrokerageMessageType, code: int, message: str) -> QuantConnect.Brokerages.BrokerageMessageEvent:
+        pass
+
+    @typing.overload
+    def __init__(self, type: QuantConnect.Brokerages.BrokerageMessageType, code: str, message: str) -> QuantConnect.Brokerages.BrokerageMessageEvent:
+        pass
+
+    def __init__(self, *args) -> QuantConnect.Brokerages.BrokerageMessageEvent:
+        pass
+
+    Code: str
+
+    Message: str
+
+    Type: QuantConnect.Brokerages.BrokerageMessageType
+
+
+
+class BrokerageMessageType(System.Enum, System.IConvertible, System.IFormattable, System.IComparable):
+    """
+    Specifies the type of message received from an IBrokerage implementation
+    
+    enum BrokerageMessageType, values: Disconnect (4), Error (2), Information (0), Reconnect (3), Warning (1)
+    """
+    value__: int
+    Disconnect: 'BrokerageMessageType'
+    Error: 'BrokerageMessageType'
+    Information: 'BrokerageMessageType'
+    Reconnect: 'BrokerageMessageType'
+    Warning: 'BrokerageMessageType'
+
+
+class BrokerageModel(System.object):
+    """ Provides factory method for creating an QuantConnect.Brokerages.IBrokerageModel from the QuantConnect.Brokerages.BrokerageName enum """
+    @staticmethod
+    def Create(orderProvider: QuantConnect.Securities.IOrderProvider, brokerage: QuantConnect.Brokerages.BrokerageName, accountType: QuantConnect.AccountType) -> QuantConnect.Brokerages.IBrokerageModel:
+        pass
+
+    __all__: list
+
+
+class BrokerageName(System.Enum, System.IConvertible, System.IFormattable, System.IComparable):
+    """
+    Specifices what transaction model and submit/execution rules to use
+    
+    enum BrokerageName, values: Alpaca (13), AlphaStreams (14), Bitfinex (5), Default (0), FxcmBrokerage (4), GDAX (12), InteractiveBrokersBrokerage (1), OandaBrokerage (3), QuantConnectBrokerage (0), TradierBrokerage (2)
+    """
+    value__: int
+    Alpaca: 'BrokerageName'
+    AlphaStreams: 'BrokerageName'
+    Bitfinex: 'BrokerageName'
+    Default: 'BrokerageName'
+    FxcmBrokerage: 'BrokerageName'
+    GDAX: 'BrokerageName'
+    InteractiveBrokersBrokerage: 'BrokerageName'
+    OandaBrokerage: 'BrokerageName'
+    QuantConnectBrokerage: 'BrokerageName'
+    TradierBrokerage: 'BrokerageName'
+
+
+class DefaultBrokerageMessageHandler(System.object, QuantConnect.Brokerages.IBrokerageMessageHandler):
+    """
+    Provides a default implementation o QuantConnect.Brokerages.IBrokerageMessageHandler that will forward
+                messages as follows:
+                Information -> IResultHandler.Debug
+                Warning     -> IResultHandler.Error && IApi.SendUserEmail
+                Error       -> IResultHandler.Error && IAlgorithm.RunTimeError
+    
+    DefaultBrokerageMessageHandler(algorithm: IAlgorithm, job: AlgorithmNodePacket, api: IApi, initialDelay: Nullable[TimeSpan], openThreshold: Nullable[TimeSpan])
+    """
+    def Handle(self, message: QuantConnect.Brokerages.BrokerageMessageEvent) -> None:
+        pass
+
+    def __init__(self, algorithm: QuantConnect.Interfaces.IAlgorithm, job: QuantConnect.Packets.AlgorithmNodePacket, api: QuantConnect.Interfaces.IApi, initialDelay: typing.Optional[datetime.timedelta], openThreshold: typing.Optional[datetime.timedelta]) -> QuantConnect.Brokerages.DefaultBrokerageMessageHandler:
+        pass

Algorithm.Python/stubs/QuantConnect/Data/Auxiliary.py

@@ -0,0 +1,335 @@
+from .__Auxiliary_1 import *
+import typing
+import System.IO
+import System.Collections.Generic
+import System
+import QuantConnect.Securities
+import QuantConnect.Interfaces
+import QuantConnect.Data.Market
+import QuantConnect.Data.Auxiliary
+import QuantConnect.Data
+import QuantConnect
+import datetime
+
+# no functions
+# classes
+
+class FactorFile(System.object, System.Collections.IEnumerable, System.Collections.Generic.IEnumerable[FactorFileRow]):
+    """
+    Represents an entire factor file for a specified symbol
+    
+    FactorFile(permtick: str, data: IEnumerable[FactorFileRow], factorFileMinimumDate: Nullable[DateTime])
+    """
+    def Apply(self, data: typing.List[QuantConnect.Data.BaseData], exchangeHours: QuantConnect.Securities.SecurityExchangeHours) -> QuantConnect.Data.Auxiliary.FactorFile:
+        pass
+
+    def GetEnumerator(self) -> System.Collections.Generic.IEnumerator[QuantConnect.Data.Auxiliary.FactorFileRow]:
+        pass
+
+    def GetPriceScaleFactor(self, searchDate: datetime.datetime) -> float:
+        pass
+
+    def GetScalingFactors(self, searchDate: datetime.datetime) -> QuantConnect.Data.Auxiliary.FactorFileRow:
+        pass
+
+    def GetSplitFactor(self, searchDate: datetime.datetime) -> float:
+        pass
+
+    def GetSplitsAndDividends(self, symbol: QuantConnect.Symbol, exchangeHours: QuantConnect.Securities.SecurityExchangeHours) -> typing.List[QuantConnect.Data.BaseData]:
+        pass
+
+    def HasDividendEventOnNextTradingDay(self, date: datetime.datetime, priceFactorRatio: float) -> bool:
+        pass
+
+    @staticmethod
+    def HasScalingFactors(permtick: str, market: str) -> bool:
+        pass
+
+    def HasSplitEventOnNextTradingDay(self, date: datetime.datetime, splitFactor: float) -> bool:
+        pass
+
+    @staticmethod
+    def Parse(permtick: str, lines: typing.List[str]) -> QuantConnect.Data.Auxiliary.FactorFile:
+        pass
+
+    @staticmethod
+    def Read(permtick: str, market: str) -> QuantConnect.Data.Auxiliary.FactorFile:
+        pass
+
+    def ToCsvLines(self) -> typing.List[str]:
+        pass
+
+    def WriteToCsv(self, symbol: QuantConnect.Symbol) -> None:
+        pass
+
+    def __init__(self, permtick: str, data: typing.List[QuantConnect.Data.Auxiliary.FactorFileRow], factorFileMinimumDate: typing.Optional[datetime.datetime]) -> QuantConnect.Data.Auxiliary.FactorFile:
+        pass
+
+    FactorFileMinimumDate: typing.Optional[datetime.datetime]
+
+    MostRecentFactorChange: datetime.datetime
+
+    Permtick: str
+
+    SortedFactorFileData: System.Collections.Generic.SortedList[datetime.datetime, QuantConnect.Data.Auxiliary.FactorFileRow]
+
+
+
+class FactorFileRow(System.object):
+    """
+    Defines a single row in a factor_factor file. This is a csv file ordered as {date, price factor, split factor, reference price}
+    
+    FactorFileRow(date: DateTime, priceFactor: Decimal, splitFactor: Decimal, referencePrice: Decimal)
+    """
+    @typing.overload
+    def Apply(self, dividend: QuantConnect.Data.Market.Dividend, exchangeHours: QuantConnect.Securities.SecurityExchangeHours) -> QuantConnect.Data.Auxiliary.FactorFileRow:
+        pass
+
+    @typing.overload
+    def Apply(self, split: QuantConnect.Data.Market.Split, exchangeHours: QuantConnect.Securities.SecurityExchangeHours) -> QuantConnect.Data.Auxiliary.FactorFileRow:
+        pass
+
+    def Apply(self, *args) -> QuantConnect.Data.Auxiliary.FactorFileRow:
+        pass
+
+    def GetDividend(self, futureFactorFileRow: QuantConnect.Data.Auxiliary.FactorFileRow, symbol: QuantConnect.Symbol, exchangeHours: QuantConnect.Securities.SecurityExchangeHours) -> QuantConnect.Data.Market.Dividend:
+        pass
+
+    def GetSplit(self, futureFactorFileRow: QuantConnect.Data.Auxiliary.FactorFileRow, symbol: QuantConnect.Symbol, exchangeHours: QuantConnect.Securities.SecurityExchangeHours) -> QuantConnect.Data.Market.Split:
+        pass
+
+    @staticmethod
+    def Parse(lines: typing.List[str], factorFileMinimumDate: typing.Optional) -> typing.List[QuantConnect.Data.Auxiliary.FactorFileRow]:
+        pass
+
+    @staticmethod
+    def Read(permtick: str, market: str, factorFileMinimumDate: typing.Optional) -> typing.List[QuantConnect.Data.Auxiliary.FactorFileRow]:
+        pass
+
+    def ToCsv(self, source: str) -> str:
+        pass
+
+    def ToString(self) -> str:
+        pass
+
+    def __init__(self, date: datetime.datetime, priceFactor: float, splitFactor: float, referencePrice: float) -> QuantConnect.Data.Auxiliary.FactorFileRow:
+        pass
+
+    Date: datetime.datetime
+
+    PriceFactor: float
+
+    PriceScaleFactor: float
+
+    ReferencePrice: float
+
+    SplitFactor: float
+
+
+
+class LocalDiskFactorFileProvider(System.object, QuantConnect.Interfaces.IFactorFileProvider):
+    """
+    Provides an implementation of QuantConnect.Interfaces.IFactorFileProvider that searches the local disk
+    
+    LocalDiskFactorFileProvider()
+    LocalDiskFactorFileProvider(mapFileProvider: IMapFileProvider)
+    """
+    def Get(self, symbol: QuantConnect.Symbol) -> QuantConnect.Data.Auxiliary.FactorFile:
+        pass
+
+    @typing.overload
+    def __init__(self) -> QuantConnect.Data.Auxiliary.LocalDiskFactorFileProvider:
+        pass
+
+    @typing.overload
+    def __init__(self, mapFileProvider: QuantConnect.Interfaces.IMapFileProvider) -> QuantConnect.Data.Auxiliary.LocalDiskFactorFileProvider:
+        pass
+
+    def __init__(self, *args) -> QuantConnect.Data.Auxiliary.LocalDiskFactorFileProvider:
+        pass
+
+
+class LocalDiskMapFileProvider(System.object, QuantConnect.Interfaces.IMapFileProvider):
+    """
+    Provides a default implementation of QuantConnect.Interfaces.IMapFileProvider that reads from
+                the local disk
+    
+    LocalDiskMapFileProvider()
+    """
+    def Get(self, market: str) -> QuantConnect.Data.Auxiliary.MapFileResolver:
+        pass
+
+
+class MapFile(System.object, System.Collections.IEnumerable, System.Collections.Generic.IEnumerable[MapFileRow]):
+    """
+    Represents an entire map file for a specified symbol
+    
+    MapFile(permtick: str, data: IEnumerable[MapFileRow])
+    """
+    def GetEnumerator(self) -> System.Collections.Generic.IEnumerator[QuantConnect.Data.Auxiliary.MapFileRow]:
+        pass
+
+    @staticmethod
+    def GetMapFilePath(permtick: str, market: str) -> str:
+        pass
+
+    @staticmethod
+    def GetMapFiles(mapFileDirectory: str) -> typing.List[QuantConnect.Data.Auxiliary.MapFile]:
+        pass
+
+    def GetMappedSymbol(self, searchDate: datetime.datetime, defaultReturnValue: str) -> str:
+        pass
+
+    def HasData(self, date: datetime.datetime) -> bool:
+        pass
+
+    @staticmethod
+    def Read(permtick: str, market: str) -> QuantConnect.Data.Auxiliary.MapFile:
+        pass
+
+    def ToCsvLines(self) -> typing.List[str]:
+        pass
+
+    def WriteToCsv(self, market: str) -> None:
+        pass
+
+    def __init__(self, permtick: str, data: typing.List[QuantConnect.Data.Auxiliary.MapFileRow]) -> QuantConnect.Data.Auxiliary.MapFile:
+        pass
+
+    DelistingDate: datetime.datetime
+
+    FirstDate: datetime.datetime
+
+    FirstTicker: str
+
+    Permtick: str
+
+
+
+class MapFileResolver(System.object, System.Collections.IEnumerable, System.Collections.Generic.IEnumerable[MapFile]):
+    """
+    Provides a means of mapping a symbol at a point in time to the map file
+                containing that share class's mapping information
+    
+    MapFileResolver(mapFiles: IEnumerable[MapFile])
+    """
+    @staticmethod
+    @typing.overload
+    def Create(dataDirectory: str, market: str) -> QuantConnect.Data.Auxiliary.MapFileResolver:
+        pass
+
+    @staticmethod
+    @typing.overload
+    def Create(mapFileDirectory: str) -> QuantConnect.Data.Auxiliary.MapFileResolver:
+        pass
+
+    def Create(self, *args) -> QuantConnect.Data.Auxiliary.MapFileResolver:
+        pass
+
+    def GetByPermtick(self, permtick: str) -> QuantConnect.Data.Auxiliary.MapFile:
+        pass
+
+    def GetEnumerator(self) -> System.Collections.Generic.IEnumerator[QuantConnect.Data.Auxiliary.MapFile]:
+        pass
+
+    def ResolveMapFile(self, symbol: str, date: datetime.datetime) -> QuantConnect.Data.Auxiliary.MapFile:
+        pass
+
+    def __init__(self, mapFiles: typing.List[QuantConnect.Data.Auxiliary.MapFile]) -> QuantConnect.Data.Auxiliary.MapFileResolver:
+        pass
+
+    Empty: 'MapFileResolver'
+
+
+class MapFileRow(System.object, System.IEquatable[MapFileRow]):
+    """
+    Represents a single row in a map_file. This is a csv file ordered as {date, mapped symbol}
+    
+    MapFileRow(date: DateTime, mappedSymbol: str)
+    """
+    @typing.overload
+    def Equals(self, other: QuantConnect.Data.Auxiliary.MapFileRow) -> bool:
+        pass
+
+    @typing.overload
+    def Equals(self, obj: object) -> bool:
+        pass
+
+    def Equals(self, *args) -> bool:
+        pass
+
+    def GetHashCode(self) -> int:
+        pass
+
+    @staticmethod
+    def Parse(line: str) -> QuantConnect.Data.Auxiliary.MapFileRow:
+        pass
+
+    @staticmethod
+    @typing.overload
+    def Read(permtick: str, market: str) -> typing.List[QuantConnect.Data.Auxiliary.MapFileRow]:
+        pass
+
+    @staticmethod
+    @typing.overload
+    def Read(path: str) -> typing.List[QuantConnect.Data.Auxiliary.MapFileRow]:
+        pass
+
+    def Read(self, *args) -> typing.List[QuantConnect.Data.Auxiliary.MapFileRow]:
+        pass
+
+    def ToCsv(self) -> str:
+        pass
+
+    def ToString(self) -> str:
+        pass
+
+    def __init__(self, date: datetime.datetime, mappedSymbol: str) -> QuantConnect.Data.Auxiliary.MapFileRow:
+        pass
+
+    Date: datetime.datetime
+
+    MappedSymbol: str
+
+
+
+class MappingExtensions(System.object):
+    """ Mapping extensions helper methods """
+    @staticmethod
+    def ResolveMapFile(mapFileResolver: QuantConnect.Data.Auxiliary.MapFileResolver, symbol: QuantConnect.Symbol, dataType: type) -> QuantConnect.Data.Auxiliary.MapFile:
+        pass
+
+    __all__: list
+
+
+class ZipEntryName(QuantConnect.Data.BaseData, QuantConnect.Data.IBaseData):
+    """
+    Defines a data type that just produces data points from the zip entry names in a zip file
+    
+    ZipEntryName()
+    """
+    @typing.overload
+    def GetSource(self, config: QuantConnect.Data.SubscriptionDataConfig, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.SubscriptionDataSource:
+        pass
+
+    @typing.overload
+    def GetSource(self, config: QuantConnect.Data.SubscriptionDataConfig, date: datetime.datetime, datafeed: QuantConnect.DataFeedEndpoint) -> str:
+        pass
+
+    def GetSource(self, *args) -> str:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, line: str, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, stream: System.IO.StreamReader, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, line: str, date: datetime.datetime, datafeed: QuantConnect.DataFeedEndpoint) -> QuantConnect.Data.BaseData:
+        pass
+
+    def Reader(self, *args) -> QuantConnect.Data.BaseData:
+        pass

Algorithm.Python/stubs/QuantConnect/Data/Consolidators.py

@@ -0,0 +1,312 @@
+from .__Consolidators_1 import *
+import typing
+import System
+import QuantConnect.Data.Market
+import QuantConnect.Data.Consolidators
+import QuantConnect.Data
+import QuantConnect
+import Python.Runtime
+import datetime
+
+# functions
+
+def FilteredIdentityDataConsolidator(*args, **kwargs): # real signature unknown
+    """ Provides factory methods for creating instances of QuantConnect.Data.Consolidators.FilteredIdentityDataConsolidator """
+    pass
+
+def RenkoConsolidator(barSize, type): # real signature unknown; restored from __doc__
+    """
+    This consolidator can transform a stream of QuantConnect.Data.BaseData instances into a stream of QuantConnect.Data.Market.RenkoBar
+    
+    RenkoConsolidator(barSize: Decimal, type: RenkoType)
+    RenkoConsolidator(barSize: Decimal, evenBars: bool)
+    RenkoConsolidator(barSize: Decimal, selector: Func[IBaseData, Decimal], volumeSelector: Func[IBaseData, Decimal], evenBars: bool)
+    RenkoConsolidator(barSize: Decimal, selector: PyObject, volumeSelector: PyObject, evenBars: bool)
+    """
+    pass
+
+# classes
+
+class BaseDataConsolidator(QuantConnect.Data.Consolidators.TradeBarConsolidatorBase[BaseData], System.IDisposable, QuantConnect.Data.Consolidators.IDataConsolidator):
+    """
+    Type capable of consolidating trade bars from any base data instance
+    
+    BaseDataConsolidator(period: TimeSpan)
+    BaseDataConsolidator(maxCount: int)
+    BaseDataConsolidator(maxCount: int, period: TimeSpan)
+    BaseDataConsolidator(func: Func[DateTime, CalendarInfo])
+    BaseDataConsolidator(pyfuncobj: PyObject)
+    """
+    @staticmethod
+    def FromResolution(resolution: QuantConnect.Resolution) -> QuantConnect.Data.Consolidators.BaseDataConsolidator:
+        pass
+
+    @typing.overload
+    def __init__(self, period: datetime.timedelta) -> QuantConnect.Data.Consolidators.BaseDataConsolidator:
+        pass
+
+    @typing.overload
+    def __init__(self, maxCount: int) -> QuantConnect.Data.Consolidators.BaseDataConsolidator:
+        pass
+
+    @typing.overload
+    def __init__(self, maxCount: int, period: datetime.timedelta) -> QuantConnect.Data.Consolidators.BaseDataConsolidator:
+        pass
+
+    @typing.overload
+    def __init__(self, func: typing.Callable[[datetime.datetime], QuantConnect.Data.Consolidators.CalendarInfo]) -> QuantConnect.Data.Consolidators.BaseDataConsolidator:
+        pass
+
+    @typing.overload
+    def __init__(self, pyfuncobj: Python.Runtime.PyObject) -> QuantConnect.Data.Consolidators.BaseDataConsolidator:
+        pass
+
+    def __init__(self, *args) -> QuantConnect.Data.Consolidators.BaseDataConsolidator:
+        pass
+
+
+
+class Calendar(System.object):
+    """ Helper class that provides System.Func used to define consolidation calendar """
+    __all__: list
+
+
+class CalendarInfo(System.object):
+    """ CalendarInfo(start: DateTime, period: TimeSpan) """
+    def __init__(self, start: datetime.datetime, period: datetime.timedelta) -> QuantConnect.Data.Consolidators.CalendarInfo:
+        pass
+
+    Period: datetime.timedelta
+    Start: datetime.datetime
+
+class CalendarType(System.object):
+    # no doc
+    __all__: list
+
+
+class DataConsolidatedHandler(System.MulticastDelegate, System.Runtime.Serialization.ISerializable, System.ICloneable):
+    """
+    Event handler type for the IDataConsolidator.DataConsolidated event
+    
+    DataConsolidatedHandler(object: object, method: IntPtr)
+    """
+    def BeginInvoke(self, sender: object, consolidated: QuantConnect.Data.IBaseData, callback: System.AsyncCallback, object: object) -> System.IAsyncResult:
+        pass
+
+    def EndInvoke(self, result: System.IAsyncResult) -> None:
+        pass
+
+    def Invoke(self, sender: object, consolidated: QuantConnect.Data.IBaseData) -> None:
+        pass
+
+    def __init__(self, object: object, method: System.IntPtr) -> QuantConnect.Data.Consolidators.DataConsolidatedHandler:
+        pass
+
+
+class DataConsolidator(System.object, System.IDisposable, QuantConnect.Data.Consolidators.IDataConsolidator):
+    # no doc
+    def Dispose(self) -> None:
+        pass
+
+    def Scan(self, currentLocalTime: datetime.datetime) -> None:
+        pass
+
+    @typing.overload
+    def Update(self, data: QuantConnect.Data.IBaseData) -> None:
+        pass
+
+    @typing.overload
+    def Update(self, data: QuantConnect.Data.Consolidators.TInput) -> None:
+        pass
+
+    def Update(self, *args) -> None:
+        pass
+
+    Consolidated: QuantConnect.Data.IBaseData
+
+    InputType: type
+
+    OutputType: type
+
+    WorkingData: QuantConnect.Data.IBaseData
+
+
+    DataConsolidated: BoundEvent
+
+
+class DynamicDataConsolidator(QuantConnect.Data.Consolidators.TradeBarConsolidatorBase[DynamicData], System.IDisposable, QuantConnect.Data.Consolidators.IDataConsolidator):
+    """
+    A data csolidator that can make trade bars from DynamicData derived types. This is useful for
+                aggregating Quandl and other highly flexible dynamic custom data types.
+    
+    DynamicDataConsolidator(period: TimeSpan)
+    DynamicDataConsolidator(maxCount: int)
+    DynamicDataConsolidator(maxCount: int, period: TimeSpan)
+    DynamicDataConsolidator(func: Func[DateTime, CalendarInfo])
+    """
+    @typing.overload
+    def __init__(self, period: datetime.timedelta) -> QuantConnect.Data.Consolidators.DynamicDataConsolidator:
+        pass
+
+    @typing.overload
+    def __init__(self, maxCount: int) -> QuantConnect.Data.Consolidators.DynamicDataConsolidator:
+        pass
+
+    @typing.overload
+    def __init__(self, maxCount: int, period: datetime.timedelta) -> QuantConnect.Data.Consolidators.DynamicDataConsolidator:
+        pass
+
+    @typing.overload
+    def __init__(self, func: typing.Callable[[datetime.datetime], QuantConnect.Data.Consolidators.CalendarInfo]) -> QuantConnect.Data.Consolidators.DynamicDataConsolidator:
+        pass
+
+    def __init__(self, *args) -> QuantConnect.Data.Consolidators.DynamicDataConsolidator:
+        pass
+
+
+
+class IDataConsolidator(System.IDisposable):
+    """
+    Represents a type capable of taking BaseData updates and firing events containing new
+                'consolidated' data. These types can be used to produce larger bars, or even be used to
+                transform the data before being sent to another component. The most common usage of these
+                types is with indicators.
+    """
+    def Scan(self, currentLocalTime: datetime.datetime) -> None:
+        pass
+
+    def Update(self, data: QuantConnect.Data.IBaseData) -> None:
+        pass
+
+    Consolidated: QuantConnect.Data.IBaseData
+
+    InputType: type
+
+    OutputType: type
+
+    WorkingData: QuantConnect.Data.IBaseData
+
+
+    DataConsolidated: BoundEvent
+
+
+class IdentityDataConsolidator(QuantConnect.Data.Consolidators.DataConsolidator[T], System.IDisposable, QuantConnect.Data.Consolidators.IDataConsolidator):
+    """ IdentityDataConsolidator[T]() """
+    def Scan(self, currentLocalTime: datetime.datetime) -> None:
+        pass
+
+    @typing.overload
+    def Update(self, data: QuantConnect.Data.Consolidators.T) -> None:
+        pass
+
+    @typing.overload
+    def Update(self, data: QuantConnect.Data.IBaseData) -> None:
+        pass
+
+    def Update(self, *args) -> None:
+        pass
+
+    OutputType: type
+
+    WorkingData: QuantConnect.Data.IBaseData
+
+
+
+class OpenInterestConsolidator(QuantConnect.Data.Consolidators.PeriodCountConsolidatorBase[Tick, OpenInterest], System.IDisposable, QuantConnect.Data.Consolidators.IDataConsolidator):
+    """
+    Type capable of consolidating open interest
+    
+    OpenInterestConsolidator(period: TimeSpan)
+    OpenInterestConsolidator(maxCount: int)
+    OpenInterestConsolidator(maxCount: int, period: TimeSpan)
+    OpenInterestConsolidator(func: Func[DateTime, CalendarInfo])
+    OpenInterestConsolidator(pyfuncobj: PyObject)
+    """
+    @staticmethod
+    def FromResolution(resolution: QuantConnect.Resolution) -> QuantConnect.Data.Consolidators.OpenInterestConsolidator:
+        pass
+
+    @typing.overload
+    def __init__(self, period: datetime.timedelta) -> QuantConnect.Data.Consolidators.OpenInterestConsolidator:
+        pass
+
+    @typing.overload
+    def __init__(self, maxCount: int) -> QuantConnect.Data.Consolidators.OpenInterestConsolidator:
+        pass
+
+    @typing.overload
+    def __init__(self, maxCount: int, period: datetime.timedelta) -> QuantConnect.Data.Consolidators.OpenInterestConsolidator:
+        pass
+
+    @typing.overload
+    def __init__(self, func: typing.Callable[[datetime.datetime], QuantConnect.Data.Consolidators.CalendarInfo]) -> QuantConnect.Data.Consolidators.OpenInterestConsolidator:
+        pass
+
+    @typing.overload
+    def __init__(self, pyfuncobj: Python.Runtime.PyObject) -> QuantConnect.Data.Consolidators.OpenInterestConsolidator:
+        pass
+
+    def __init__(self, *args) -> QuantConnect.Data.Consolidators.OpenInterestConsolidator:
+        pass
+
+
+
+class PeriodCountConsolidatorBase(QuantConnect.Data.Consolidators.DataConsolidator[T], System.IDisposable, QuantConnect.Data.Consolidators.IDataConsolidator):
+    # no doc
+    def Scan(self, currentLocalTime: datetime.datetime) -> None:
+        pass
+
+    @typing.overload
+    def Update(self, data: QuantConnect.Data.Consolidators.T) -> None:
+        pass
+
+    @typing.overload
+    def Update(self, data: QuantConnect.Data.IBaseData) -> None:
+        pass
+
+    def Update(self, *args) -> None:
+        pass
+
+    def __init__(self, *args): #cannot find CLR constructor
+        pass
+
+    OutputType: type
+
+    WorkingData: QuantConnect.Data.IBaseData
+
+
+    DataConsolidated: BoundEvent
+
+
+class QuoteBarConsolidator(QuantConnect.Data.Consolidators.PeriodCountConsolidatorBase[QuoteBar, QuoteBar], System.IDisposable, QuantConnect.Data.Consolidators.IDataConsolidator):
+    """
+    Consolidates QuoteBars into larger QuoteBars
+    
+    QuoteBarConsolidator(period: TimeSpan)
+    QuoteBarConsolidator(maxCount: int)
+    QuoteBarConsolidator(maxCount: int, period: TimeSpan)
+    QuoteBarConsolidator(func: Func[DateTime, CalendarInfo])
+    QuoteBarConsolidator(pyfuncobj: PyObject)
+    """
+    @typing.overload
+    def __init__(self, period: datetime.timedelta) -> QuantConnect.Data.Consolidators.QuoteBarConsolidator:
+        pass
+
+    @typing.overload
+    def __init__(self, maxCount: int) -> QuantConnect.Data.Consolidators.QuoteBarConsolidator:
+        pass
+
+    @typing.overload
+    def __init__(self, maxCount: int, period: datetime.timedelta) -> QuantConnect.Data.Consolidators.QuoteBarConsolidator:
+        pass
+
+    @typing.overload
+    def __init__(self, func: typing.Callable[[datetime.datetime], QuantConnect.Data.Consolidators.CalendarInfo]) -> QuantConnect.Data.Consolidators.QuoteBarConsolidator:
+        pass
+
+    @typing.overload
+    def __init__(self, pyfuncobj: Python.Runtime.PyObject) -> QuantConnect.Data.Consolidators.QuoteBarConsolidator:
+        pass
+
+    def __init__(self, *args) -> QuantConnect.Data.Consolidators.QuoteBarConsolidator:
+        pass

Algorithm.Python/stubs/QuantConnect/Data/Custom/Benzinga.py

@@ -0,0 +1,138 @@
+# encoding: utf-8
+# module QuantConnect.Data.Custom.Benzinga calls itself Benzinga
+# from QuantConnect.Common, Version=2.4.0.0, Culture=neutral, PublicKeyToken=null
+# by generator 1.145
+# no doc
+
+# imports
+import datetime
+import Newtonsoft.Json
+import Newtonsoft.Json.Linq
+import NodaTime
+import QuantConnect
+import QuantConnect.Data
+import QuantConnect.Data.Custom.Benzinga
+import System
+import System.IO
+import typing
+
+# no functions
+# classes
+
+class BenzingaNews(QuantConnect.Data.IndexedBaseData, QuantConnect.Data.IBaseData):
+    """
+    News data powered by Benzinga - https://docs.benzinga.io/benzinga/newsfeed-v2.html
+    
+    BenzingaNews()
+    """
+    @typing.overload
+    def Clone(self) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Clone(self, fillForward: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    def Clone(self, *args) -> QuantConnect.Data.BaseData:
+        pass
+
+    def DataTimeZone(self) -> NodaTime.DateTimeZone:
+        pass
+
+    def DefaultResolution(self) -> QuantConnect.Resolution:
+        pass
+
+    @typing.overload
+    def GetSource(self, config: QuantConnect.Data.SubscriptionDataConfig, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.SubscriptionDataSource:
+        pass
+
+    @typing.overload
+    def GetSource(self, config: QuantConnect.Data.SubscriptionDataConfig, date: datetime.datetime, datafeed: QuantConnect.DataFeedEndpoint) -> str:
+        pass
+
+    def GetSource(self, *args) -> str:
+        pass
+
+    def GetSourceForAnIndex(self, config: QuantConnect.Data.SubscriptionDataConfig, date: datetime.datetime, index: str, isLiveMode: bool) -> QuantConnect.Data.SubscriptionDataSource:
+        pass
+
+    def IsSparseData(self) -> bool:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, line: str, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, stream: System.IO.StreamReader, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, line: str, date: datetime.datetime, datafeed: QuantConnect.DataFeedEndpoint) -> QuantConnect.Data.BaseData:
+        pass
+
+    def Reader(self, *args) -> QuantConnect.Data.BaseData:
+        pass
+
+    def RequiresMapping(self) -> bool:
+        pass
+
+    def SupportedResolutions(self) -> typing.List[QuantConnect.Resolution]:
+        pass
+
+    def ToString(self) -> str:
+        pass
+
+    Author: str
+
+    Categories: typing.List[str]
+
+    Contents: str
+
+    CreatedAt: datetime.datetime
+
+    EndTime: datetime.datetime
+
+    Id: int
+
+    Symbols: typing.List[QuantConnect.Symbol]
+
+    Tags: typing.List[str]
+
+    Teaser: str
+
+    Title: str
+
+    UpdatedAt: datetime.datetime
+
+
+
+class BenzingaNewsJsonConverter(Newtonsoft.Json.JsonConverter):
+    """
+    Helper json converter class used to convert Benzinga news data
+                 into QuantConnect.Data.Custom.Benzinga.BenzingaNews
+                
+                 An example schema of the data in a serialized format is provided
+                 to help you better understand this converter.
+    
+    BenzingaNewsJsonConverter(symbol: Symbol, liveMode: bool)
+    """
+    def CanConvert(self, objectType: type) -> bool:
+        pass
+
+    @staticmethod
+    def DeserializeNews(item: Newtonsoft.Json.Linq.JToken, enableLogging: bool) -> QuantConnect.Data.Custom.Benzinga.BenzingaNews:
+        pass
+
+    def ReadJson(self, reader: Newtonsoft.Json.JsonReader, objectType: type, existingValue: object, serializer: Newtonsoft.Json.JsonSerializer) -> object:
+        pass
+
+    def WriteJson(self, writer: Newtonsoft.Json.JsonWriter, value: object, serializer: Newtonsoft.Json.JsonSerializer) -> None:
+        pass
+
+    def __init__(self, symbol: QuantConnect.Symbol, liveMode: bool) -> QuantConnect.Data.Custom.Benzinga.BenzingaNewsJsonConverter:
+        pass
+
+    ShareClassMappedTickers: Dictionary[str, HashSet[str]]
+
+

Algorithm.Python/stubs/QuantConnect/Data/Custom/CBOE.py

@@ -0,0 +1,61 @@
+# encoding: utf-8
+# module QuantConnect.Data.Custom.CBOE calls itself CBOE
+# from QuantConnect.Common, Version=2.4.0.0, Culture=neutral, PublicKeyToken=null
+# by generator 1.145
+# no doc
+
+# imports
+import datetime
+import QuantConnect
+import QuantConnect.Data
+import System
+import System.IO
+import typing
+
+# no functions
+# classes
+
+class CBOE(QuantConnect.Data.Market.TradeBar, QuantConnect.Data.Market.IBar, QuantConnect.Data.Market.IBaseDataBar, QuantConnect.Data.IBaseData):
+    """ CBOE() """
+    def DefaultResolution(self) -> QuantConnect.Resolution:
+        pass
+
+    @typing.overload
+    def GetSource(self, config: QuantConnect.Data.SubscriptionDataConfig, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.SubscriptionDataSource:
+        pass
+
+    @typing.overload
+    def GetSource(self, config: QuantConnect.Data.SubscriptionDataConfig, date: datetime.datetime, datafeed: QuantConnect.DataFeedEndpoint) -> str:
+        pass
+
+    def GetSource(self, *args) -> str:
+        pass
+
+    def IsSparseData(self) -> bool:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, line: str, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, stream: System.IO.StreamReader, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, line: str, date: datetime.datetime, datafeed: QuantConnect.DataFeedEndpoint) -> QuantConnect.Data.BaseData:
+        pass
+
+    def Reader(self, *args) -> QuantConnect.Data.BaseData:
+        pass
+
+    def RequiresMapping(self) -> bool:
+        pass
+
+    def SupportedResolutions(self) -> typing.List[QuantConnect.Resolution]:
+        pass
+
+    def ToString(self) -> str:
+        pass
+
+

Algorithm.Python/stubs/QuantConnect/Data/Custom/Estimize.py

@@ -0,0 +1,284 @@
+# encoding: utf-8
+# module QuantConnect.Data.Custom.Estimize calls itself Estimize
+# from QuantConnect.Common, Version=2.4.0.0, Culture=neutral, PublicKeyToken=null
+# by generator 1.145
+# no doc
+
+# imports
+import datetime
+import NodaTime
+import QuantConnect
+import QuantConnect.Data
+import QuantConnect.Data.Custom.Estimize
+import System
+import System.IO
+import typing
+
+# no functions
+# classes
+
+class EstimizeConsensus(QuantConnect.Data.BaseData, QuantConnect.Data.IBaseData):
+    """
+    Consensus of the specified release
+    
+    EstimizeConsensus()
+    EstimizeConsensus(csvLine: str)
+    """
+    def DataTimeZone(self) -> NodaTime.DateTimeZone:
+        pass
+
+    @typing.overload
+    def GetSource(self, config: QuantConnect.Data.SubscriptionDataConfig, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.SubscriptionDataSource:
+        pass
+
+    @typing.overload
+    def GetSource(self, config: QuantConnect.Data.SubscriptionDataConfig, date: datetime.datetime, datafeed: QuantConnect.DataFeedEndpoint) -> str:
+        pass
+
+    def GetSource(self, *args) -> str:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, line: str, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, stream: System.IO.StreamReader, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, line: str, date: datetime.datetime, datafeed: QuantConnect.DataFeedEndpoint) -> QuantConnect.Data.BaseData:
+        pass
+
+    def Reader(self, *args) -> QuantConnect.Data.BaseData:
+        pass
+
+    def RequiresMapping(self) -> bool:
+        pass
+
+    def ToString(self) -> str:
+        pass
+
+    @typing.overload
+    def __init__(self) -> QuantConnect.Data.Custom.Estimize.EstimizeConsensus:
+        pass
+
+    @typing.overload
+    def __init__(self, csvLine: str) -> QuantConnect.Data.Custom.Estimize.EstimizeConsensus:
+        pass
+
+    def __init__(self, *args) -> QuantConnect.Data.Custom.Estimize.EstimizeConsensus:
+        pass
+
+    Count: typing.Optional[int]
+
+    EndTime: datetime.datetime
+
+    FiscalQuarter: typing.Optional[int]
+
+    FiscalYear: typing.Optional[int]
+
+    High: typing.Optional[float]
+
+    Id: str
+
+    Low: typing.Optional[float]
+
+    Mean: typing.Optional[float]
+
+    Source: typing.Optional[QuantConnect.Data.Custom.Estimize.Source]
+
+    StandardDeviation: typing.Optional[float]
+
+    Type: typing.Optional[QuantConnect.Data.Custom.Estimize.Type]
+
+    UpdatedAt: datetime.datetime
+
+    Value: float
+
+
+
+class EstimizeEstimate(QuantConnect.Data.BaseData, QuantConnect.Data.IBaseData):
+    """
+    Financial estimates for the specified company
+    
+    EstimizeEstimate()
+    EstimizeEstimate(csvLine: str)
+    """
+    def DataTimeZone(self) -> NodaTime.DateTimeZone:
+        pass
+
+    @typing.overload
+    def GetSource(self, config: QuantConnect.Data.SubscriptionDataConfig, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.SubscriptionDataSource:
+        pass
+
+    @typing.overload
+    def GetSource(self, config: QuantConnect.Data.SubscriptionDataConfig, date: datetime.datetime, datafeed: QuantConnect.DataFeedEndpoint) -> str:
+        pass
+
+    def GetSource(self, *args) -> str:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, line: str, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, stream: System.IO.StreamReader, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, line: str, date: datetime.datetime, datafeed: QuantConnect.DataFeedEndpoint) -> QuantConnect.Data.BaseData:
+        pass
+
+    def Reader(self, *args) -> QuantConnect.Data.BaseData:
+        pass
+
+    def RequiresMapping(self) -> bool:
+        pass
+
+    def ToString(self) -> str:
+        pass
+
+    @typing.overload
+    def __init__(self) -> QuantConnect.Data.Custom.Estimize.EstimizeEstimate:
+        pass
+
+    @typing.overload
+    def __init__(self, csvLine: str) -> QuantConnect.Data.Custom.Estimize.EstimizeEstimate:
+        pass
+
+    def __init__(self, *args) -> QuantConnect.Data.Custom.Estimize.EstimizeEstimate:
+        pass
+
+    AnalystId: str
+
+    CreatedAt: datetime.datetime
+
+    EndTime: datetime.datetime
+
+    Eps: typing.Optional[float]
+
+    FiscalQuarter: int
+
+    FiscalYear: int
+
+    Flagged: bool
+
+    Id: str
+
+    Revenue: typing.Optional[float]
+
+    Ticker: str
+
+    UserName: str
+
+    Value: float
+
+
+
+class EstimizeRelease(QuantConnect.Data.BaseData, QuantConnect.Data.IBaseData):
+    """
+    Financial releases for the specified company
+    
+    EstimizeRelease()
+    EstimizeRelease(csvLine: str)
+    """
+    def DataTimeZone(self) -> NodaTime.DateTimeZone:
+        pass
+
+    @typing.overload
+    def GetSource(self, config: QuantConnect.Data.SubscriptionDataConfig, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.SubscriptionDataSource:
+        pass
+
+    @typing.overload
+    def GetSource(self, config: QuantConnect.Data.SubscriptionDataConfig, date: datetime.datetime, datafeed: QuantConnect.DataFeedEndpoint) -> str:
+        pass
+
+    def GetSource(self, *args) -> str:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, line: str, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, stream: System.IO.StreamReader, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, line: str, date: datetime.datetime, datafeed: QuantConnect.DataFeedEndpoint) -> QuantConnect.Data.BaseData:
+        pass
+
+    def Reader(self, *args) -> QuantConnect.Data.BaseData:
+        pass
+
+    def RequiresMapping(self) -> bool:
+        pass
+
+    def ToString(self) -> str:
+        pass
+
+    @typing.overload
+    def __init__(self) -> QuantConnect.Data.Custom.Estimize.EstimizeRelease:
+        pass
+
+    @typing.overload
+    def __init__(self, csvLine: str) -> QuantConnect.Data.Custom.Estimize.EstimizeRelease:
+        pass
+
+    def __init__(self, *args) -> QuantConnect.Data.Custom.Estimize.EstimizeRelease:
+        pass
+
+    ConsensusEpsEstimate: typing.Optional[float]
+
+    ConsensusRevenueEstimate: typing.Optional[float]
+
+    ConsensusWeightedEpsEstimate: typing.Optional[float]
+
+    ConsensusWeightedRevenueEstimate: typing.Optional[float]
+
+    EndTime: datetime.datetime
+
+    Eps: typing.Optional[float]
+
+    FiscalQuarter: int
+
+    FiscalYear: int
+
+    Id: str
+
+    ReleaseDate: datetime.datetime
+
+    Revenue: typing.Optional[float]
+
+    Value: float
+
+    WallStreetEpsEstimate: typing.Optional[float]
+
+    WallStreetRevenueEstimate: typing.Optional[float]
+
+
+
+class Source(System.Enum, System.IConvertible, System.IFormattable, System.IComparable):
+    """
+    Source of the Consensus
+    
+    enum Source, values: Estimize (1), WallStreet (0)
+    """
+    value__: int
+    Estimize: 'Source'
+    WallStreet: 'Source'
+
+
+class Type(System.Enum, System.IConvertible, System.IFormattable, System.IComparable):
+    """
+    Type of the consensus
+    
+    enum Type, values: Eps (0), Revenue (1)
+    """
+    value__: int
+    Eps: 'Type'
+    Revenue: 'Type'
+
+

Algorithm.Python/stubs/QuantConnect/Data/Custom/Fred.py

@@ -0,0 +1,157 @@
+# encoding: utf-8
+# module QuantConnect.Data.Custom.Fred calls itself Fred
+# from QuantConnect.Common, Version=2.4.0.0, Culture=neutral, PublicKeyToken=null
+# by generator 1.145
+# no doc
+
+# imports
+import datetime
+import QuantConnect
+import QuantConnect.Data
+import QuantConnect.Data.Custom.Fred
+import System
+import System.IO
+import typing
+
+# no functions
+# classes
+
+class Fred(QuantConnect.Data.BaseData, QuantConnect.Data.IBaseData):
+    """ Fred() """
+    @typing.overload
+    def Clone(self) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Clone(self, fillForward: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    def Clone(self, *args) -> QuantConnect.Data.BaseData:
+        pass
+
+    def DefaultResolution(self) -> QuantConnect.Resolution:
+        pass
+
+    @typing.overload
+    def GetSource(self, config: QuantConnect.Data.SubscriptionDataConfig, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.SubscriptionDataSource:
+        pass
+
+    @typing.overload
+    def GetSource(self, config: QuantConnect.Data.SubscriptionDataConfig, date: datetime.datetime, datafeed: QuantConnect.DataFeedEndpoint) -> str:
+        pass
+
+    def GetSource(self, *args) -> str:
+        pass
+
+    def IsSparseData(self) -> bool:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, line: str, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, stream: System.IO.StreamReader, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, line: str, date: datetime.datetime, datafeed: QuantConnect.DataFeedEndpoint) -> QuantConnect.Data.BaseData:
+        pass
+
+    def Reader(self, *args) -> QuantConnect.Data.BaseData:
+        pass
+
+    def RequiresMapping(self) -> bool:
+        pass
+
+    def SupportedResolutions(self) -> typing.List[QuantConnect.Resolution]:
+        pass
+
+    def ToString(self) -> str:
+        pass
+
+    CBOE: type
+    CentralBankInterventions: type
+    CommercialPaper: type
+    ICEBofAML: type
+    LIBOR: type
+    OECDRecessionIndicators: type
+    TradeWeightedIndexes: type
+    Wilshire: type
+
+
+class FredApi(QuantConnect.Data.BaseData, QuantConnect.Data.IBaseData):
+    """ FredApi() """
+    @typing.overload
+    def GetSource(self, config: QuantConnect.Data.SubscriptionDataConfig, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.SubscriptionDataSource:
+        pass
+
+    @typing.overload
+    def GetSource(self, config: QuantConnect.Data.SubscriptionDataConfig, date: datetime.datetime, datafeed: QuantConnect.DataFeedEndpoint) -> str:
+        pass
+
+    def GetSource(self, *args) -> str:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, content: str, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, stream: System.IO.StreamReader, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, line: str, date: datetime.datetime, datafeed: QuantConnect.DataFeedEndpoint) -> QuantConnect.Data.BaseData:
+        pass
+
+    def Reader(self, *args) -> QuantConnect.Data.BaseData:
+        pass
+
+    @staticmethod
+    def SetAuthCode(authCode: str) -> None:
+        pass
+
+    Count: int
+
+    FileType: str
+
+    Limit: int
+
+    ObservationEnd: str
+
+    Observations: typing.List[QuantConnect.Data.Custom.Fred.Observation]
+
+    ObservationStart: str
+
+    Offset: int
+
+    OrderBy: str
+
+    OutputType: int
+
+    RealtimeEnd: str
+
+    RealtimeStart: str
+
+    SortOrder: str
+
+    Units: str
+
+
+    AuthCode: str
+    IsAuthCodeSet: bool
+
+
+class Observation(System.object):
+    """ Observation() """
+    Date: datetime.datetime
+
+    RealtimeEnd: str
+
+    RealtimeStart: str
+
+    Value: str
+
+
+

Algorithm.Python/stubs/QuantConnect/Data/Custom/Intrinio.py

@@ -0,0 +1,109 @@
+# encoding: utf-8
+# module QuantConnect.Data.Custom.Intrinio calls itself Intrinio
+# from QuantConnect.Common, Version=2.4.0.0, Culture=neutral, PublicKeyToken=null
+# by generator 1.145
+# no doc
+
+# imports
+import datetime
+import QuantConnect
+import QuantConnect.Data
+import QuantConnect.Data.Custom.Intrinio
+import System
+import System.IO
+import typing
+
+# no functions
+# classes
+
+class IntrinioConfig(System.object):
+    """ Auxiliary class to access all Intrinio API data. """
+    @staticmethod
+    def SetTimeIntervalBetweenCalls(timeSpan: datetime.timedelta) -> None:
+        pass
+
+    @staticmethod
+    def SetUserAndPassword(user: str, password: str) -> None:
+        pass
+
+    IsInitialized: bool
+    Password: str
+    RateGate: RateGate
+    User: str
+    __all__: list
+
+
+class IntrinioDataTransformation(System.Enum, System.IConvertible, System.IFormattable, System.IComparable):
+    """
+    TRanformation available for the Economic data.
+    
+    enum IntrinioDataTransformation, values: AnnualyCCRoc (3), AnnualyPc (8), AnnualyRoc (1), CCRoc (4), CompoundedAnnualRoc (2), Level (5), Ln (6), Pc (7), Roc (0)
+    """
+    value__: int
+    AnnualyCCRoc: 'IntrinioDataTransformation'
+    AnnualyPc: 'IntrinioDataTransformation'
+    AnnualyRoc: 'IntrinioDataTransformation'
+    CCRoc: 'IntrinioDataTransformation'
+    CompoundedAnnualRoc: 'IntrinioDataTransformation'
+    Level: 'IntrinioDataTransformation'
+    Ln: 'IntrinioDataTransformation'
+    Pc: 'IntrinioDataTransformation'
+    Roc: 'IntrinioDataTransformation'
+
+
+class IntrinioEconomicData(QuantConnect.Data.BaseData, QuantConnect.Data.IBaseData):
+    """
+    Access the massive repository of economic data from the Federal Reserve Economic Data system via the Intrinio API.
+    
+    IntrinioEconomicData()
+    IntrinioEconomicData(dataTransformation: IntrinioDataTransformation)
+    """
+    @typing.overload
+    def GetSource(self, config: QuantConnect.Data.SubscriptionDataConfig, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.SubscriptionDataSource:
+        pass
+
+    @typing.overload
+    def GetSource(self, config: QuantConnect.Data.SubscriptionDataConfig, date: datetime.datetime, datafeed: QuantConnect.DataFeedEndpoint) -> str:
+        pass
+
+    def GetSource(self, *args) -> str:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, line: str, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, stream: System.IO.StreamReader, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, line: str, date: datetime.datetime, datafeed: QuantConnect.DataFeedEndpoint) -> QuantConnect.Data.BaseData:
+        pass
+
+    def Reader(self, *args) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def __init__(self) -> QuantConnect.Data.Custom.Intrinio.IntrinioEconomicData:
+        pass
+
+    @typing.overload
+    def __init__(self, dataTransformation: QuantConnect.Data.Custom.Intrinio.IntrinioDataTransformation) -> QuantConnect.Data.Custom.Intrinio.IntrinioEconomicData:
+        pass
+
+    def __init__(self, *args) -> QuantConnect.Data.Custom.Intrinio.IntrinioEconomicData:
+        pass
+
+
+class IntrinioEconomicDataSources(System.object):
+    # no doc
+    BofAMerrillLynch: type
+    CBOE: type
+    Commodities: type
+    ExchangeRates: type
+    Moodys: type
+    TradeWeightedUsDollaIndex: type
+    __all__: list
+
+

Algorithm.Python/stubs/QuantConnect/Data/Custom/SEC.py

@@ -0,0 +1,299 @@
+from .__SEC_1 import *
+import typing
+import System.IO
+import System
+import QuantConnect.Data.Custom.SEC
+import QuantConnect.Data
+import QuantConnect
+import datetime
+
+# no functions
+# classes
+
+class ISECReport(QuantConnect.Data.IBaseData):
+    """
+    Base interface for all SEC report types.
+                Using an interface, we can retrieve all report types with a single
+                call to QuantConnect.Data.Slice.Get
+    """
+    Report: QuantConnect.Data.Custom.SEC.SECReportSubmission
+
+
+
+class SECReport10K(QuantConnect.Data.BaseData, QuantConnect.Data.Custom.SEC.ISECReport, QuantConnect.Data.IBaseData):
+    """
+    SEC 10-K report (annual earnings) QuantConnect.Data.BaseData implementation.
+                Using this class, you can retrieve SEC report data for a security if it exists.
+                If the ticker you want no longer trades, you can also use the CIK of the company
+                you want data for as well except for currently traded stocks. This may change in the future.
+    
+    SECReport10K()
+    SECReport10K(report: SECReportSubmission)
+    """
+    @typing.overload
+    def Clone(self) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Clone(self, fillForward: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    def Clone(self, *args) -> QuantConnect.Data.BaseData:
+        pass
+
+    def DefaultResolution(self) -> QuantConnect.Resolution:
+        pass
+
+    @typing.overload
+    def GetSource(self, config: QuantConnect.Data.SubscriptionDataConfig, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.SubscriptionDataSource:
+        pass
+
+    @typing.overload
+    def GetSource(self, config: QuantConnect.Data.SubscriptionDataConfig, date: datetime.datetime, datafeed: QuantConnect.DataFeedEndpoint) -> str:
+        pass
+
+    def GetSource(self, *args) -> str:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, line: str, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, stream: System.IO.StreamReader, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, line: str, date: datetime.datetime, datafeed: QuantConnect.DataFeedEndpoint) -> QuantConnect.Data.BaseData:
+        pass
+
+    def Reader(self, *args) -> QuantConnect.Data.BaseData:
+        pass
+
+    def RequiresMapping(self) -> bool:
+        pass
+
+    def SupportedResolutions(self) -> typing.List[QuantConnect.Resolution]:
+        pass
+
+    @typing.overload
+    def __init__(self) -> QuantConnect.Data.Custom.SEC.SECReport10K:
+        pass
+
+    @typing.overload
+    def __init__(self, report: QuantConnect.Data.Custom.SEC.SECReportSubmission) -> QuantConnect.Data.Custom.SEC.SECReport10K:
+        pass
+
+    def __init__(self, *args) -> QuantConnect.Data.Custom.SEC.SECReport10K:
+        pass
+
+    Report: QuantConnect.Data.Custom.SEC.SECReportSubmission
+
+
+
+class SECReport10Q(QuantConnect.Data.BaseData, QuantConnect.Data.Custom.SEC.ISECReport, QuantConnect.Data.IBaseData):
+    """
+    SEC 10-Q report (quarterly earnings) QuantConnect.Data.BaseData implementation.
+                Using this class, you can retrieve SEC report data for a security if it exists.
+                If the ticker you want no longer trades, you can also use the CIK of the company
+                you want data for as well except for currently traded stocks. This may change in the future.
+    
+    SECReport10Q()
+    SECReport10Q(report: SECReportSubmission)
+    """
+    @typing.overload
+    def Clone(self) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Clone(self, fillForward: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    def Clone(self, *args) -> QuantConnect.Data.BaseData:
+        pass
+
+    def DefaultResolution(self) -> QuantConnect.Resolution:
+        pass
+
+    @typing.overload
+    def GetSource(self, config: QuantConnect.Data.SubscriptionDataConfig, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.SubscriptionDataSource:
+        pass
+
+    @typing.overload
+    def GetSource(self, config: QuantConnect.Data.SubscriptionDataConfig, date: datetime.datetime, datafeed: QuantConnect.DataFeedEndpoint) -> str:
+        pass
+
+    def GetSource(self, *args) -> str:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, line: str, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, stream: System.IO.StreamReader, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, line: str, date: datetime.datetime, datafeed: QuantConnect.DataFeedEndpoint) -> QuantConnect.Data.BaseData:
+        pass
+
+    def Reader(self, *args) -> QuantConnect.Data.BaseData:
+        pass
+
+    def RequiresMapping(self) -> bool:
+        pass
+
+    def SupportedResolutions(self) -> typing.List[QuantConnect.Resolution]:
+        pass
+
+    @typing.overload
+    def __init__(self) -> QuantConnect.Data.Custom.SEC.SECReport10Q:
+        pass
+
+    @typing.overload
+    def __init__(self, report: QuantConnect.Data.Custom.SEC.SECReportSubmission) -> QuantConnect.Data.Custom.SEC.SECReport10Q:
+        pass
+
+    def __init__(self, *args) -> QuantConnect.Data.Custom.SEC.SECReport10Q:
+        pass
+
+    Report: QuantConnect.Data.Custom.SEC.SECReportSubmission
+
+
+
+class SECReport8K(QuantConnect.Data.BaseData, QuantConnect.Data.Custom.SEC.ISECReport, QuantConnect.Data.IBaseData):
+    """
+    SEC 8-K report (important investor notices) QuantConnect.Data.BaseData implementation.
+                Using this class, you can retrieve SEC report data for a security if it exists.
+                If the ticker you want no longer trades, you can also use the CIK of the company
+                you want data for as well except for currently traded stocks. This may change in the future.
+    
+    SECReport8K()
+    SECReport8K(report: SECReportSubmission)
+    """
+    @typing.overload
+    def Clone(self) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Clone(self, fillForward: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    def Clone(self, *args) -> QuantConnect.Data.BaseData:
+        pass
+
+    def DefaultResolution(self) -> QuantConnect.Resolution:
+        pass
+
+    @typing.overload
+    def GetSource(self, config: QuantConnect.Data.SubscriptionDataConfig, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.SubscriptionDataSource:
+        pass
+
+    @typing.overload
+    def GetSource(self, config: QuantConnect.Data.SubscriptionDataConfig, date: datetime.datetime, datafeed: QuantConnect.DataFeedEndpoint) -> str:
+        pass
+
+    def GetSource(self, *args) -> str:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, line: str, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, stream: System.IO.StreamReader, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, line: str, date: datetime.datetime, datafeed: QuantConnect.DataFeedEndpoint) -> QuantConnect.Data.BaseData:
+        pass
+
+    def Reader(self, *args) -> QuantConnect.Data.BaseData:
+        pass
+
+    def RequiresMapping(self) -> bool:
+        pass
+
+    def SupportedResolutions(self) -> typing.List[QuantConnect.Resolution]:
+        pass
+
+    @typing.overload
+    def __init__(self) -> QuantConnect.Data.Custom.SEC.SECReport8K:
+        pass
+
+    @typing.overload
+    def __init__(self, report: QuantConnect.Data.Custom.SEC.SECReportSubmission) -> QuantConnect.Data.Custom.SEC.SECReport8K:
+        pass
+
+    def __init__(self, *args) -> QuantConnect.Data.Custom.SEC.SECReport8K:
+        pass
+
+    Report: QuantConnect.Data.Custom.SEC.SECReportSubmission
+
+
+
+class SECReportBusinessAddress(System.object):
+    """ SECReportBusinessAddress() """
+    City: str
+    Phone: str
+    State: str
+    StreetOne: str
+    StreetTwo: str
+    Zip: str
+
+class SECReportCompanyData(System.object):
+    """ SECReportCompanyData() """
+    AssignedSic: str
+    Cik: str
+    ConformedName: str
+    FiscalYearEnd: str
+    IrsNumber: str
+    StateOfIncorporation: str
+
+class SECReportDateTimeConverter(Newtonsoft.Json.Converters.IsoDateTimeConverter):
+    """
+    Specifies format for parsing System.DateTime values from SEC data
+    
+    SECReportDateTimeConverter()
+    """
+
+class SECReportDocument(System.object):
+    """ SECReportDocument() """
+    Description: str
+    Filename: str
+    FormType: str
+    Sequence: int
+    Text: str
+
+class SECReportFactory(System.object):
+    """ SECReportFactory() """
+    def CreateSECReport(self, xmlText: str) -> QuantConnect.Data.Custom.SEC.ISECReport:
+        pass
+
+
+class SECReportFiler(System.object):
+    """ SECReportFiler() """
+    BusinessAddress: typing.List[QuantConnect.Data.Custom.SEC.SECReportBusinessAddress]
+    CompanyData: QuantConnect.Data.Custom.SEC.SECReportCompanyData
+    FormerCompanies: typing.List[QuantConnect.Data.Custom.SEC.SECReportFormerCompany]
+    MailingAddress: typing.List[QuantConnect.Data.Custom.SEC.SECReportMailAddress]
+    Values: typing.List[QuantConnect.Data.Custom.SEC.SECReportFilingValues]
+
+class SECReportFilingValues(System.object):
+    """ SECReportFilingValues() """
+    Act: str
+    FileNumber: str
+    FilmNumber: str
+    FormType: str
+
+class SECReportFormerCompany(System.object):
+    """ SECReportFormerCompany() """
+    Changed: datetime.datetime
+    FormerConformedName: str
+
+class SECReportIndexDirectory(System.object):
+    """ SECReportIndexDirectory() """
+    Items: typing.List[QuantConnect.Data.Custom.SEC.SECReportIndexItem]
+    Name: str
+    ParentDirectory: str

Algorithm.Python/stubs/QuantConnect/Data/Custom/SmartInsider.py

@@ -0,0 +1,345 @@
+from .__SmartInsider_1 import *
+import typing
+import System.IO
+import System
+import QuantConnect.Data.Custom.SmartInsider
+import QuantConnect.Data
+import QuantConnect
+import NodaTime
+import datetime
+
+# no functions
+# classes
+
+class SmartInsiderEvent(QuantConnect.Data.BaseData, QuantConnect.Data.IBaseData):
+    """
+    SmartInsider Intention and Transaction events. These are fields
+                that are shared between intentions and transactions.
+    
+    SmartInsiderEvent()
+    SmartInsiderEvent(tsvLine: str)
+    """
+    def DataTimeZone(self) -> NodaTime.DateTimeZone:
+        pass
+
+    def FromRawData(self, line: str) -> None:
+        pass
+
+    @staticmethod
+    def ParseDate(date: str) -> datetime.datetime:
+        pass
+
+    def ToLine(self) -> str:
+        pass
+
+    @typing.overload
+    def __init__(self) -> QuantConnect.Data.Custom.SmartInsider.SmartInsiderEvent:
+        pass
+
+    @typing.overload
+    def __init__(self, tsvLine: str) -> QuantConnect.Data.Custom.SmartInsider.SmartInsiderEvent:
+        pass
+
+    def __init__(self, *args) -> QuantConnect.Data.Custom.SmartInsider.SmartInsiderEvent:
+        pass
+
+    AnnouncedIn: str
+
+    AnnouncementDate: typing.Optional[datetime.datetime]
+
+    CompanyID: typing.Optional[int]
+
+    CompanyName: str
+
+    EventType: typing.Optional[QuantConnect.Data.Custom.SmartInsider.SmartInsiderEventType]
+
+    ICBCode: typing.Optional[int]
+
+    ICBIndustry: str
+
+    ICBSector: str
+
+    ICBSubSector: str
+
+    ICBSuperSector: str
+
+    ISIN: str
+
+    LastCloseEnded: typing.Optional[datetime.datetime]
+
+    LastIDsUpdate: typing.Optional[datetime.datetime]
+
+    LastUpdate: datetime.datetime
+
+    NextCloseBegin: typing.Optional[datetime.datetime]
+
+    NextResultsAnnouncementsDate: typing.Optional[datetime.datetime]
+
+    PreviousResultsAnnouncementDate: typing.Optional[datetime.datetime]
+
+    SecurityDescription: str
+
+    TickerCountry: str
+
+    TickerSymbol: str
+
+    TimeProcessed: typing.Optional[datetime.datetime]
+
+    TimeProcessedUtc: typing.Optional[datetime.datetime]
+
+    TimeReleased: typing.Optional[datetime.datetime]
+
+    TimeReleasedUtc: typing.Optional[datetime.datetime]
+
+    TransactionID: str
+
+    USDMarketCap: typing.Optional[float]
+
+
+
+class SmartInsiderEventType(System.Enum, System.IConvertible, System.IFormattable, System.IComparable):
+    """
+    Describes what will or has taken place in an execution
+    
+    enum SmartInsiderEventType, values: Authorization (0), Cancellation (6), DownwardsRevision (4), Intention (1), NotSpecified (10), PlanReStarted (9), PlanSuspension (8), RevisedDetails (5), SeekAuthorization (7), Transaction (2), UpwardsRevision (3)
+    """
+    value__: int
+    Authorization: 'SmartInsiderEventType'
+    Cancellation: 'SmartInsiderEventType'
+    DownwardsRevision: 'SmartInsiderEventType'
+    Intention: 'SmartInsiderEventType'
+    NotSpecified: 'SmartInsiderEventType'
+    PlanReStarted: 'SmartInsiderEventType'
+    PlanSuspension: 'SmartInsiderEventType'
+    RevisedDetails: 'SmartInsiderEventType'
+    SeekAuthorization: 'SmartInsiderEventType'
+    Transaction: 'SmartInsiderEventType'
+    UpwardsRevision: 'SmartInsiderEventType'
+
+
+class SmartInsiderExecution(System.Enum, System.IConvertible, System.IFormattable, System.IComparable):
+    """
+    Describes how the transaction was executed
+    
+    enum SmartInsiderExecution, values: Market (0), OffMarket (2), TenderOffer (1)
+    """
+    value__: int
+    Market: 'SmartInsiderExecution'
+    OffMarket: 'SmartInsiderExecution'
+    TenderOffer: 'SmartInsiderExecution'
+
+
+class SmartInsiderExecutionEntity(System.Enum, System.IConvertible, System.IFormattable, System.IComparable):
+    """
+    Entity that intends to or executed the transaction
+    
+    enum SmartInsiderExecutionEntity, values: Broker (2), EmployeeBenefitTrust (4), EmployerBenefitTrust (3), Issuer (0), Subsidiary (1), ThirdParty (5)
+    """
+    value__: int
+    Broker: 'SmartInsiderExecutionEntity'
+    EmployeeBenefitTrust: 'SmartInsiderExecutionEntity'
+    EmployerBenefitTrust: 'SmartInsiderExecutionEntity'
+    Issuer: 'SmartInsiderExecutionEntity'
+    Subsidiary: 'SmartInsiderExecutionEntity'
+    ThirdParty: 'SmartInsiderExecutionEntity'
+
+
+class SmartInsiderExecutionHolding(System.Enum, System.IConvertible, System.IFormattable, System.IComparable):
+    """
+    Details regarding the way holdings will be or were processed in a buyback execution
+    
+    enum SmartInsiderExecutionHolding, values: Cancellation (1), Error (6), NotReported (4), SatisfyEmployeeTax (3), SatisfyStockVesting (5), Treasury (0), Trust (2)
+    """
+    value__: int
+    Cancellation: 'SmartInsiderExecutionHolding'
+    Error: 'SmartInsiderExecutionHolding'
+    NotReported: 'SmartInsiderExecutionHolding'
+    SatisfyEmployeeTax: 'SmartInsiderExecutionHolding'
+    SatisfyStockVesting: 'SmartInsiderExecutionHolding'
+    Treasury: 'SmartInsiderExecutionHolding'
+    Trust: 'SmartInsiderExecutionHolding'
+
+
+class SmartInsiderIntention(QuantConnect.Data.Custom.SmartInsider.SmartInsiderEvent, QuantConnect.Data.IBaseData):
+    """
+    Smart Insider Intentions - Intention to execute a stock buyback and details about the future event
+    
+    SmartInsiderIntention()
+    SmartInsiderIntention(line: str)
+    """
+    @typing.overload
+    def Clone(self) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Clone(self, fillForward: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    def Clone(self, *args) -> QuantConnect.Data.BaseData:
+        pass
+
+    def FromRawData(self, line: str) -> None:
+        pass
+
+    @typing.overload
+    def GetSource(self, config: QuantConnect.Data.SubscriptionDataConfig, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.SubscriptionDataSource:
+        pass
+
+    @typing.overload
+    def GetSource(self, config: QuantConnect.Data.SubscriptionDataConfig, date: datetime.datetime, datafeed: QuantConnect.DataFeedEndpoint) -> str:
+        pass
+
+    def GetSource(self, *args) -> str:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, line: str, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, stream: System.IO.StreamReader, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, line: str, date: datetime.datetime, datafeed: QuantConnect.DataFeedEndpoint) -> QuantConnect.Data.BaseData:
+        pass
+
+    def Reader(self, *args) -> QuantConnect.Data.BaseData:
+        pass
+
+    def ToLine(self) -> str:
+        pass
+
+    @typing.overload
+    def __init__(self) -> QuantConnect.Data.Custom.SmartInsider.SmartInsiderIntention:
+        pass
+
+    @typing.overload
+    def __init__(self, line: str) -> QuantConnect.Data.Custom.SmartInsider.SmartInsiderIntention:
+        pass
+
+    def __init__(self, *args) -> QuantConnect.Data.Custom.SmartInsider.SmartInsiderIntention:
+        pass
+
+    Amount: typing.Optional[int]
+
+    AmountValue: typing.Optional[int]
+
+    AuthorizationEndDate: typing.Optional[datetime.datetime]
+
+    AuthorizationStartDate: typing.Optional[datetime.datetime]
+
+    Execution: typing.Optional[QuantConnect.Data.Custom.SmartInsider.SmartInsiderExecution]
+
+    ExecutionEntity: typing.Optional[QuantConnect.Data.Custom.SmartInsider.SmartInsiderExecutionEntity]
+
+    ExecutionHolding: typing.Optional[QuantConnect.Data.Custom.SmartInsider.SmartInsiderExecutionHolding]
+
+    MaximumPrice: typing.Optional[float]
+
+    MinimumPrice: typing.Optional[float]
+
+    NoteText: str
+
+    Percentage: typing.Optional[float]
+
+    PriceCurrency: str
+
+    ValueCurrency: str
+
+
+
+class SmartInsiderTransaction(QuantConnect.Data.Custom.SmartInsider.SmartInsiderEvent, QuantConnect.Data.IBaseData):
+    """
+    Smart Insider Transaction - Execution of a stock buyback and details about the event occurred
+    
+    SmartInsiderTransaction()
+    SmartInsiderTransaction(line: str)
+    """
+    @typing.overload
+    def Clone(self) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Clone(self, fillForward: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    def Clone(self, *args) -> QuantConnect.Data.BaseData:
+        pass
+
+    def FromRawData(self, line: str) -> None:
+        pass
+
+    @typing.overload
+    def GetSource(self, config: QuantConnect.Data.SubscriptionDataConfig, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.SubscriptionDataSource:
+        pass
+
+    @typing.overload
+    def GetSource(self, config: QuantConnect.Data.SubscriptionDataConfig, date: datetime.datetime, datafeed: QuantConnect.DataFeedEndpoint) -> str:
+        pass
+
+    def GetSource(self, *args) -> str:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, line: str, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, stream: System.IO.StreamReader, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, line: str, date: datetime.datetime, datafeed: QuantConnect.DataFeedEndpoint) -> QuantConnect.Data.BaseData:
+        pass
+
+    def Reader(self, *args) -> QuantConnect.Data.BaseData:
+        pass
+
+    def ToLine(self) -> str:
+        pass
+
+    @typing.overload
+    def __init__(self) -> QuantConnect.Data.Custom.SmartInsider.SmartInsiderTransaction:
+        pass
+
+    @typing.overload
+    def __init__(self, line: str) -> QuantConnect.Data.Custom.SmartInsider.SmartInsiderTransaction:
+        pass
+
+    def __init__(self, *args) -> QuantConnect.Data.Custom.SmartInsider.SmartInsiderTransaction:
+        pass
+
+    Amount: typing.Optional[float]
+
+    AmountAdjustedFactor: typing.Optional[float]
+
+    BuybackDate: typing.Optional[datetime.datetime]
+
+    BuybackPercentage: typing.Optional[float]
+
+    ConversionRate: typing.Optional[float]
+
+    Currency: str
+
+    EURValue: typing.Optional[float]
+
+    Execution: typing.Optional[QuantConnect.Data.Custom.SmartInsider.SmartInsiderExecution]
+
+    ExecutionEntity: typing.Optional[QuantConnect.Data.Custom.SmartInsider.SmartInsiderExecutionEntity]
+
+    ExecutionHolding: typing.Optional[QuantConnect.Data.Custom.SmartInsider.SmartInsiderExecutionHolding]
+
+    ExecutionPrice: typing.Optional[float]
+
+    GBPValue: typing.Optional[float]
+
+    NoteText: str
+
+    PriceAdjustedFactor: typing.Optional[float]
+
+    TreasuryHolding: typing.Optional[int]
+
+    USDValue: typing.Optional[float]
+
+    VolumePercentage: typing.Optional[float]

Algorithm.Python/stubs/QuantConnect/Data/Custom/Tiingo.py

@@ -0,0 +1,216 @@
+# encoding: utf-8
+# module QuantConnect.Data.Custom.Tiingo calls itself Tiingo
+# from QuantConnect.Common, Version=2.4.0.0, Culture=neutral, PublicKeyToken=null
+# by generator 1.145
+# no doc
+
+# imports
+import datetime
+import Newtonsoft.Json
+import Newtonsoft.Json.Linq
+import NodaTime
+import QuantConnect
+import QuantConnect.Data
+import QuantConnect.Data.Custom.Tiingo
+import System
+import System.IO
+import typing
+
+# no functions
+# classes
+
+class Tiingo(System.object):
+    """ Helper class for Tiingo configuration """
+    @staticmethod
+    def SetAuthCode(authCode: str) -> None:
+        pass
+
+    AuthCode: str
+    IsAuthCodeSet: bool
+    __all__: list
+
+
+class TiingoPrice(QuantConnect.Data.Market.TradeBar, QuantConnect.Data.Market.IBar, QuantConnect.Data.Market.IBaseDataBar, QuantConnect.Data.IBaseData):
+    """
+    Tiingo daily price data
+                https://api.tiingo.com/docs/tiingo/daily
+    
+    TiingoPrice()
+    """
+    def DataTimeZone(self) -> NodaTime.DateTimeZone:
+        pass
+
+    def DefaultResolution(self) -> QuantConnect.Resolution:
+        pass
+
+    @typing.overload
+    def GetSource(self, config: QuantConnect.Data.SubscriptionDataConfig, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.SubscriptionDataSource:
+        pass
+
+    @typing.overload
+    def GetSource(self, config: QuantConnect.Data.SubscriptionDataConfig, date: datetime.datetime, datafeed: QuantConnect.DataFeedEndpoint) -> str:
+        pass
+
+    def GetSource(self, *args) -> str:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, content: str, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, stream: System.IO.StreamReader, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, line: str, date: datetime.datetime, datafeed: QuantConnect.DataFeedEndpoint) -> QuantConnect.Data.BaseData:
+        pass
+
+    def Reader(self, *args) -> QuantConnect.Data.BaseData:
+        pass
+
+    def RequiresMapping(self) -> bool:
+        pass
+
+    def SupportedResolutions(self) -> typing.List[QuantConnect.Resolution]:
+        pass
+
+    AdjustedClose: float
+
+    AdjustedHigh: float
+
+    AdjustedLow: float
+
+    AdjustedOpen: float
+
+    AdjustedVolume: int
+
+    Close: float
+
+    Date: datetime.datetime
+
+    Dividend: float
+
+    EndTime: datetime.datetime
+
+    High: float
+
+    Low: float
+
+    Open: float
+
+    Period: datetime.timedelta
+
+    SplitFactor: float
+
+    Volume: float
+
+
+
+class TiingoDailyData(QuantConnect.Data.Custom.Tiingo.TiingoPrice, QuantConnect.Data.Market.IBar, QuantConnect.Data.Market.IBaseDataBar, QuantConnect.Data.IBaseData):
+    """
+    Tiingo daily price data
+                https://api.tiingo.com/docs/tiingo/daily
+    
+    TiingoDailyData()
+    """
+
+class TiingoNews(QuantConnect.Data.IndexedBaseData, QuantConnect.Data.IBaseData):
+    """
+    Tiingo news data
+                https://api.tiingo.com/documentation/news
+    
+    TiingoNews()
+    """
+    def DataTimeZone(self) -> NodaTime.DateTimeZone:
+        pass
+
+    @typing.overload
+    def GetSource(self, config: QuantConnect.Data.SubscriptionDataConfig, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.SubscriptionDataSource:
+        pass
+
+    @typing.overload
+    def GetSource(self, config: QuantConnect.Data.SubscriptionDataConfig, date: datetime.datetime, datafeed: QuantConnect.DataFeedEndpoint) -> str:
+        pass
+
+    def GetSource(self, *args) -> str:
+        pass
+
+    def GetSourceForAnIndex(self, config: QuantConnect.Data.SubscriptionDataConfig, date: datetime.datetime, index: str, isLiveMode: bool) -> QuantConnect.Data.SubscriptionDataSource:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, content: str, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, stream: System.IO.StreamReader, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, line: str, date: datetime.datetime, datafeed: QuantConnect.DataFeedEndpoint) -> QuantConnect.Data.BaseData:
+        pass
+
+    def Reader(self, *args) -> QuantConnect.Data.BaseData:
+        pass
+
+    def RequiresMapping(self) -> bool:
+        pass
+
+    ArticleID: str
+
+    CrawlDate: datetime.datetime
+
+    Description: str
+
+    PublishedDate: datetime.datetime
+
+    Source: str
+
+    Symbols: typing.List[QuantConnect.Symbol]
+
+    Tags: typing.List[str]
+
+    Title: str
+
+    Url: str
+
+
+
+class TiingoNewsJsonConverter(Newtonsoft.Json.JsonConverter):
+    """
+    Helper json converter class used to convert a list of Tiingo news data
+                into System.Collections.Generic.List
+    
+    TiingoNewsJsonConverter(symbol: Symbol)
+    """
+    def CanConvert(self, objectType: type) -> bool:
+        pass
+
+    @staticmethod
+    def DeserializeNews(token: Newtonsoft.Json.Linq.JToken) -> QuantConnect.Data.Custom.Tiingo.TiingoNews:
+        pass
+
+    def ReadJson(self, reader: Newtonsoft.Json.JsonReader, objectType: type, existingValue: object, serializer: Newtonsoft.Json.JsonSerializer) -> object:
+        pass
+
+    def WriteJson(self, writer: Newtonsoft.Json.JsonWriter, value: object, serializer: Newtonsoft.Json.JsonSerializer) -> None:
+        pass
+
+    def __init__(self, symbol: QuantConnect.Symbol) -> QuantConnect.Data.Custom.Tiingo.TiingoNewsJsonConverter:
+        pass
+
+
+class TiingoSymbolMapper(System.object):
+    """ Helper class to map a Lean format ticker to Tiingo format """
+    @staticmethod
+    def GetLeanTicker(ticker: str) -> str:
+        pass
+
+    @staticmethod
+    def GetTiingoTicker(symbol: QuantConnect.Symbol) -> str:
+        pass
+
+    __all__: list
+
+

Algorithm.Python/stubs/QuantConnect/Data/Custom/TradingEconomics.py

@@ -0,0 +1,297 @@
+# encoding: utf-8
+# module QuantConnect.Data.Custom.TradingEconomics calls itself TradingEconomics
+# from QuantConnect.Common, Version=2.4.0.0, Culture=neutral, PublicKeyToken=null
+# by generator 1.145
+# no doc
+
+# imports
+import datetime
+import Newtonsoft.Json
+import NodaTime
+import QuantConnect
+import QuantConnect.Data
+import QuantConnect.Data.Custom.TradingEconomics
+import System
+import System.IO
+import typing
+
+# no functions
+# classes
+
+class EarningsType(System.Enum, System.IConvertible, System.IFormattable, System.IComparable):
+    """
+    Earnings type: earnings, ipo, dividends
+    
+    enum EarningsType, values: Dividends (2), Earnings (0), IPO (1), Split (3)
+    """
+    value__: int
+    Dividends: 'EarningsType'
+    Earnings: 'EarningsType'
+    IPO: 'EarningsType'
+    Split: 'EarningsType'
+
+
+class TradingEconomics(System.object):
+    """ TradingEconomics static class contains shortcut definitions of major Trading Economics Indicators available """
+    Calendar: type
+    Event: type
+    Indicator: type
+    __all__: list
+
+
+class TradingEconomicsCalendar(QuantConnect.Data.BaseData, QuantConnect.Data.IBaseData):
+    """
+    Represents the Trading Economics Calendar information:
+                The economic calendar covers around 1600 events for more than 150 countries a month.
+                https://docs.tradingeconomics.com/#events
+    
+    TradingEconomicsCalendar()
+    """
+    @typing.overload
+    def Clone(self) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Clone(self, fillForward: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    def Clone(self, *args) -> QuantConnect.Data.BaseData:
+        pass
+
+    @staticmethod
+    def CountryToCurrencyCode(country: str) -> str:
+        pass
+
+    def DataTimeZone(self) -> NodaTime.DateTimeZone:
+        pass
+
+    @typing.overload
+    def GetSource(self, config: QuantConnect.Data.SubscriptionDataConfig, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.SubscriptionDataSource:
+        pass
+
+    @typing.overload
+    def GetSource(self, config: QuantConnect.Data.SubscriptionDataConfig, date: datetime.datetime, datafeed: QuantConnect.DataFeedEndpoint) -> str:
+        pass
+
+    def GetSource(self, *args) -> str:
+        pass
+
+    @staticmethod
+    def ParseDecimal(value: str, inPercent: bool) -> typing.Optional[float]:
+        pass
+
+    @staticmethod
+    def ProcessAPIResponse(content: str) -> typing.List[QuantConnect.Data.Custom.TradingEconomics.TradingEconomicsCalendar]:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, line: str, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, stream: System.IO.StreamReader, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, line: str, date: datetime.datetime, datafeed: QuantConnect.DataFeedEndpoint) -> QuantConnect.Data.BaseData:
+        pass
+
+    def Reader(self, *args) -> QuantConnect.Data.BaseData:
+        pass
+
+    @staticmethod
+    def SetAuthCode(authCode: str) -> None:
+        pass
+
+    def ToCsv(self) -> str:
+        pass
+
+    def ToString(self) -> str:
+        pass
+
+    Actual: typing.Optional[float]
+
+    CalendarId: str
+
+    Category: str
+
+    Country: str
+
+    DateSpan: str
+
+    EndTime: datetime.datetime
+
+    Event: str
+
+    EventRaw: str
+
+    Forecast: typing.Optional[float]
+
+    Importance: QuantConnect.Data.Custom.TradingEconomics.TradingEconomicsImportance
+
+    IsPercentage: bool
+
+    LastUpdate: datetime.datetime
+
+    OCategory: str
+
+    OCountry: str
+
+    Previous: typing.Optional[float]
+
+    Reference: str
+
+    Revised: typing.Optional[float]
+
+    Source: str
+
+    Ticker: str
+
+    TradingEconomicsForecast: typing.Optional[float]
+
+
+    AuthCode: str
+    IsAuthCodeSet: bool
+
+
+class TradingEconomicsDateTimeConverter(Newtonsoft.Json.JsonConverter):
+    """
+    DateTime JSON Converter that handles null value
+    
+    TradingEconomicsDateTimeConverter()
+    """
+    def CanConvert(self, objectType: type) -> bool:
+        pass
+
+    def ReadJson(self, reader: Newtonsoft.Json.JsonReader, objectType: type, existingValue: object, serializer: Newtonsoft.Json.JsonSerializer) -> object:
+        pass
+
+    def WriteJson(self, writer: Newtonsoft.Json.JsonWriter, value: object, serializer: Newtonsoft.Json.JsonSerializer) -> None:
+        pass
+
+
+class TradingEconomicsEarnings(QuantConnect.Data.BaseData, QuantConnect.Data.IBaseData):
+    """
+    Represents the Trading Economics Earnings information.
+                https://docs.tradingeconomics.com/#earnings
+    
+    TradingEconomicsEarnings()
+    """
+    def DataTimeZone(self) -> NodaTime.DateTimeZone:
+        pass
+
+    Actual: typing.Optional[float]
+
+    CalendarReference: str
+
+    Country: str
+
+    Currency: str
+
+    EarningsType: QuantConnect.Data.Custom.TradingEconomics.EarningsType
+
+    EndTime: datetime.datetime
+
+    FiscalReference: str
+
+    FiscalTag: str
+
+    Forecast: typing.Optional[float]
+
+    LastUpdate: datetime.datetime
+
+    Name: str
+
+    Symbol: str
+
+    Value: float
+
+
+
+class TradingEconomicsEventFilter(System.object):
+    """ Provides methods to filter and standardize Trading Economics calendar event names. """
+    @staticmethod
+    def FilterEvent(eventName: str) -> str:
+        pass
+
+    __all__: list
+
+
+class TradingEconomicsImportance(System.Enum, System.IConvertible, System.IFormattable, System.IComparable):
+    """
+    Importance of a TradingEconomics information
+    
+    enum TradingEconomicsImportance, values: High (2), Low (0), Medium (1)
+    """
+    value__: int
+    High: 'TradingEconomicsImportance'
+    Low: 'TradingEconomicsImportance'
+    Medium: 'TradingEconomicsImportance'
+
+
+class TradingEconomicsIndicator(QuantConnect.Data.BaseData, QuantConnect.Data.IBaseData):
+    """
+    Represents the Trading Economics Indicator information.
+                https://docs.tradingeconomics.com/#indicators
+    
+    TradingEconomicsIndicator()
+    """
+    @typing.overload
+    def Clone(self) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Clone(self, fillForward: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    def Clone(self, *args) -> QuantConnect.Data.BaseData:
+        pass
+
+    def DataTimeZone(self) -> NodaTime.DateTimeZone:
+        pass
+
+    @typing.overload
+    def GetSource(self, config: QuantConnect.Data.SubscriptionDataConfig, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.SubscriptionDataSource:
+        pass
+
+    @typing.overload
+    def GetSource(self, config: QuantConnect.Data.SubscriptionDataConfig, date: datetime.datetime, datafeed: QuantConnect.DataFeedEndpoint) -> str:
+        pass
+
+    def GetSource(self, *args) -> str:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, content: str, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, stream: System.IO.StreamReader, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, line: str, date: datetime.datetime, datafeed: QuantConnect.DataFeedEndpoint) -> QuantConnect.Data.BaseData:
+        pass
+
+    def Reader(self, *args) -> QuantConnect.Data.BaseData:
+        pass
+
+    def ToString(self) -> str:
+        pass
+
+    Category: str
+
+    Country: str
+
+    EndTime: datetime.datetime
+
+    Frequency: str
+
+    HistoricalDataSymbol: str
+
+    LastUpdate: datetime.datetime
+
+    Value: float
+
+
+

Algorithm.Python/stubs/QuantConnect/Data/Custom/USEnergy.py

@@ -0,0 +1,78 @@
+# encoding: utf-8
+# module QuantConnect.Data.Custom.USEnergy calls itself USEnergy
+# from QuantConnect.Common, Version=2.4.0.0, Culture=neutral, PublicKeyToken=null
+# by generator 1.145
+# no doc
+
+# imports
+import datetime
+import QuantConnect
+import QuantConnect.Data
+import System
+import System.IO
+import typing
+
+# no functions
+# classes
+
+class USEnergy(QuantConnect.Data.BaseData, QuantConnect.Data.IBaseData):
+    """
+    United States Energy Information Administration (EIA). This loads U.S. Energy data from QuantConnect's cache.
+    
+    USEnergy()
+    """
+    @typing.overload
+    def Clone(self) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Clone(self, fillForward: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    def Clone(self, *args) -> QuantConnect.Data.BaseData:
+        pass
+
+    def DefaultResolution(self) -> QuantConnect.Resolution:
+        pass
+
+    @typing.overload
+    def GetSource(self, config: QuantConnect.Data.SubscriptionDataConfig, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.SubscriptionDataSource:
+        pass
+
+    @typing.overload
+    def GetSource(self, config: QuantConnect.Data.SubscriptionDataConfig, date: datetime.datetime, datafeed: QuantConnect.DataFeedEndpoint) -> str:
+        pass
+
+    def GetSource(self, *args) -> str:
+        pass
+
+    def IsSparseData(self) -> bool:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, line: str, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, stream: System.IO.StreamReader, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, line: str, date: datetime.datetime, datafeed: QuantConnect.DataFeedEndpoint) -> QuantConnect.Data.BaseData:
+        pass
+
+    def Reader(self, *args) -> QuantConnect.Data.BaseData:
+        pass
+
+    def RequiresMapping(self) -> bool:
+        pass
+
+    def SupportedResolutions(self) -> typing.List[QuantConnect.Resolution]:
+        pass
+
+    def ToString(self) -> str:
+        pass
+
+    Petroleum: type
+
+

Algorithm.Python/stubs/QuantConnect/Data/Custom/USTreasury.py

@@ -0,0 +1,92 @@
+# encoding: utf-8
+# module QuantConnect.Data.Custom.USTreasury calls itself USTreasury
+# from QuantConnect.Common, Version=2.4.0.0, Culture=neutral, PublicKeyToken=null
+# by generator 1.145
+# no doc
+
+# imports
+import datetime
+import QuantConnect
+import QuantConnect.Data
+import System
+import System.IO
+import typing
+
+# no functions
+# classes
+
+class USTreasuryYieldCurveRate(QuantConnect.Data.BaseData, QuantConnect.Data.IBaseData):
+    """
+    U.S. Treasury yield curve data
+    
+    USTreasuryYieldCurveRate()
+    """
+    @typing.overload
+    def Clone(self) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Clone(self, fillForward: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    def Clone(self, *args) -> QuantConnect.Data.BaseData:
+        pass
+
+    def DefaultResolution(self) -> QuantConnect.Resolution:
+        pass
+
+    @typing.overload
+    def GetSource(self, config: QuantConnect.Data.SubscriptionDataConfig, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.SubscriptionDataSource:
+        pass
+
+    @typing.overload
+    def GetSource(self, config: QuantConnect.Data.SubscriptionDataConfig, date: datetime.datetime, datafeed: QuantConnect.DataFeedEndpoint) -> str:
+        pass
+
+    def GetSource(self, *args) -> str:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, line: str, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, stream: System.IO.StreamReader, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, line: str, date: datetime.datetime, datafeed: QuantConnect.DataFeedEndpoint) -> QuantConnect.Data.BaseData:
+        pass
+
+    def Reader(self, *args) -> QuantConnect.Data.BaseData:
+        pass
+
+    def SupportedResolutions(self) -> typing.List[QuantConnect.Resolution]:
+        pass
+
+    FiveYear: typing.Optional[float]
+
+    OneMonth: typing.Optional[float]
+
+    OneYear: typing.Optional[float]
+
+    SevenYear: typing.Optional[float]
+
+    SixMonth: typing.Optional[float]
+
+    TenYear: typing.Optional[float]
+
+    ThirtyYear: typing.Optional[float]
+
+    ThreeMonth: typing.Optional[float]
+
+    ThreeYear: typing.Optional[float]
+
+    TwentyYear: typing.Optional[float]
+
+    TwoMonth: typing.Optional[float]
+
+    TwoYear: typing.Optional[float]
+
+
+

Algorithm.Python/stubs/QuantConnect/Data/Custom/__SEC_1.py

@@ -0,0 +1,39 @@
+import typing
+import System.IO
+import System
+import QuantConnect.Data.Custom.SEC
+import QuantConnect.Data
+import QuantConnect
+import datetime
+
+class SECReportIndexFile(System.object):
+    """ SECReportIndexFile() """
+    Directory: QuantConnect.Data.Custom.SEC.SECReportIndexDirectory
+
+class SECReportIndexItem(System.object):
+    """ SECReportIndexItem() """
+    FileType: str
+    LastModified: datetime.datetime
+    Name: str
+    Size: str
+
+class SECReportMailAddress(System.object):
+    """ SECReportMailAddress() """
+    City: str
+    State: str
+    StreetOne: str
+    StreetTwo: str
+    Zip: str
+
+class SECReportSubmission(System.object):
+    """ SECReportSubmission() """
+    AccessionNumber: str
+    Documents: typing.List[QuantConnect.Data.Custom.SEC.SECReportDocument]
+    Filers: typing.List[QuantConnect.Data.Custom.SEC.SECReportFiler]
+    FilingDate: datetime.datetime
+    FilingDateChange: datetime.datetime
+    FormType: str
+    Items: typing.List[str]
+    MadeAvailableAt: datetime.datetime
+    Period: datetime.datetime
+    PublicDocumentCount: str

Algorithm.Python/stubs/QuantConnect/Data/Custom/__init__.py

@@ -0,0 +1,189 @@
+import typing
+import System.IO
+import System
+import QuantConnect.Data.Custom
+import QuantConnect.Data
+import QuantConnect
+import datetime
+
+# no functions
+# classes
+
+class FxcmVolume(QuantConnect.Data.BaseData, QuantConnect.Data.IBaseData):
+    """
+    FXCM Real FOREX Volume and Transaction data from its clients base, available for the following pairs:
+                    - EURUSD, USDJPY, GBPUSD, USDCHF, EURCHF, AUDUSD, USDCAD,
+                      NZDUSD, EURGBP, EURJPY, GBPJPY, EURAUD, EURCAD, AUDJPY
+                    FXCM only provides support for FX symbols which produced over 110 million average daily volume (ADV) during 2013.
+                    This limit is imposed to ensure we do not highlight low volume/low ticket symbols in addition to other financial
+                    reporting concerns.
+    
+    FxcmVolume()
+    """
+    @typing.overload
+    def GetSource(self, config: QuantConnect.Data.SubscriptionDataConfig, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.SubscriptionDataSource:
+        pass
+
+    @typing.overload
+    def GetSource(self, config: QuantConnect.Data.SubscriptionDataConfig, date: datetime.datetime, datafeed: QuantConnect.DataFeedEndpoint) -> str:
+        pass
+
+    def GetSource(self, *args) -> str:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, line: str, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, stream: System.IO.StreamReader, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, line: str, date: datetime.datetime, datafeed: QuantConnect.DataFeedEndpoint) -> QuantConnect.Data.BaseData:
+        pass
+
+    def Reader(self, *args) -> QuantConnect.Data.BaseData:
+        pass
+
+    Transactions: int
+
+    Volume: int
+
+
+
+class NullData(QuantConnect.Data.BaseData, QuantConnect.Data.IBaseData):
+    """
+    Represents a custom data type that works as a heartbeat of data in live mode
+    
+    NullData()
+    """
+    @typing.overload
+    def GetSource(self, config: QuantConnect.Data.SubscriptionDataConfig, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.SubscriptionDataSource:
+        pass
+
+    @typing.overload
+    def GetSource(self, config: QuantConnect.Data.SubscriptionDataConfig, date: datetime.datetime, datafeed: QuantConnect.DataFeedEndpoint) -> str:
+        pass
+
+    def GetSource(self, *args) -> str:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, line: str, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, stream: System.IO.StreamReader, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, line: str, date: datetime.datetime, datafeed: QuantConnect.DataFeedEndpoint) -> QuantConnect.Data.BaseData:
+        pass
+
+    def Reader(self, *args) -> QuantConnect.Data.BaseData:
+        pass
+
+    EndTime: datetime.datetime
+
+
+
+class Quandl(QuantConnect.Data.DynamicData, System.Dynamic.IDynamicMetaObjectProvider, QuantConnect.Data.IBaseData):
+    """
+    Quandl Data Type - Import generic data from quandl, without needing to define Reader methods.
+                This reads the headers of the data imported, and dynamically creates properties for the imported data.
+    
+    Quandl()
+    """
+    @typing.overload
+    def GetSource(self, config: QuantConnect.Data.SubscriptionDataConfig, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.SubscriptionDataSource:
+        pass
+
+    @typing.overload
+    def GetSource(self, config: QuantConnect.Data.SubscriptionDataConfig, date: datetime.datetime, datafeed: QuantConnect.DataFeedEndpoint) -> str:
+        pass
+
+    def GetSource(self, *args) -> str:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, line: str, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, stream: System.IO.StreamReader, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, line: str, date: datetime.datetime, datafeed: QuantConnect.DataFeedEndpoint) -> QuantConnect.Data.BaseData:
+        pass
+
+    def Reader(self, *args) -> QuantConnect.Data.BaseData:
+        pass
+
+    @staticmethod
+    def SetAuthCode(authCode: str) -> None:
+        pass
+
+    def __init__(self) -> QuantConnect.Data.Custom.Quandl:
+        pass
+
+    EndTime: datetime.datetime
+
+    Period: datetime.timedelta
+
+
+    IsAuthCodeSet: bool
+
+
+class USEnergyAPI(QuantConnect.Data.BaseData, QuantConnect.Data.IBaseData):
+    """
+    US Energy Information Administration provides extensive data on energy usage, import, export,
+                and forecasting across all US energy sectors.
+                https://www.eia.gov/opendata/
+    
+    USEnergyAPI()
+    """
+    def DefaultResolution(self) -> QuantConnect.Resolution:
+        pass
+
+    @typing.overload
+    def GetSource(self, config: QuantConnect.Data.SubscriptionDataConfig, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.SubscriptionDataSource:
+        pass
+
+    @typing.overload
+    def GetSource(self, config: QuantConnect.Data.SubscriptionDataConfig, date: datetime.datetime, datafeed: QuantConnect.DataFeedEndpoint) -> str:
+        pass
+
+    def GetSource(self, *args) -> str:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, content: str, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, stream: System.IO.StreamReader, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, line: str, date: datetime.datetime, datafeed: QuantConnect.DataFeedEndpoint) -> QuantConnect.Data.BaseData:
+        pass
+
+    def Reader(self, *args) -> QuantConnect.Data.BaseData:
+        pass
+
+    @staticmethod
+    def SetAuthCode(authCode: str) -> None:
+        pass
+
+    def SupportedResolutions(self) -> typing.List[QuantConnect.Resolution]:
+        pass
+
+    EndTime: datetime.datetime
+
+    EnergyDataPointCloseTime: datetime.datetime
+
+
+    AuthCode: str
+    IsAuthCodeSet: bool

Algorithm.Python/stubs/QuantConnect/Data/Fundamental.py

@@ -0,0 +1,324 @@
+from .__Fundamental_1 import *
+import typing
+import System.IO
+import System.Collections.Generic
+import System
+import QuantConnect.Data.Fundamental.MultiPeriodField
+import QuantConnect.Data.Fundamental
+import QuantConnect.Data
+import QuantConnect
+import datetime
+
+# no functions
+# classes
+
+class MultiPeriodField(System.object):
+    """ Abstract base class for multi-period fields """
+    def GetPeriodNames(self) -> typing.List[str]:
+        pass
+
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def GetPeriodValues(self) -> System.Collections.Generic.IReadOnlyDictionary[str, float]:
+        pass
+
+    def HasPeriodValue(self, period: str) -> bool:
+        pass
+
+    def HasValues(self) -> bool:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def ToString(self) -> str:
+        pass
+
+    def UpdateValues(self, update: QuantConnect.Data.Fundamental.MultiPeriodField) -> None:
+        pass
+
+    def __init__(self, *args): #cannot find CLR constructor
+        pass
+
+    HasValue: bool
+
+    Value: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+    PeriodField: type
+
+
+class AccountsPayableBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Any money that a company owes its suppliers for goods and services purchased on credit and is expected to pay within the next
+                year or operating cycle.
+    
+    AccountsPayableBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.AccountsPayableBalanceSheet:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class AccountsReceivableBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Accounts owed to a company by customers within a year as a result of exchanging goods or services on credit.
+    
+    AccountsReceivableBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.AccountsReceivableBalanceSheet:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class AccruedandDeferredIncomeBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Sum of accrued liabilities and deferred income (amount received in advance but the services are not provided in respect of
+                amount).
+    
+    AccruedandDeferredIncomeBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.AccruedandDeferredIncomeBalanceSheet:
+        pass
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class AccruedandDeferredIncomeCurrentBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Sum of Accrued Liabilities and Deferred Income (amount received in advance but the services are not provided in respect of
+                amount) due within 1 year.
+    
+    AccruedandDeferredIncomeCurrentBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.AccruedandDeferredIncomeCurrentBalanceSheet:
+        pass
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class AccruedandDeferredIncomeNonCurrentBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Sum of Accrued Liabilities and Deferred Income (amount received in advance but the services are not provided in respect of
+                amount) due after 1 year.
+    
+    AccruedandDeferredIncomeNonCurrentBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.AccruedandDeferredIncomeNonCurrentBalanceSheet:
+        pass
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class AccruedInterestReceivableBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    This account shows the amount of unpaid interest accrued to the date of purchase and included in the purchase price of securities
+                purchased between interest dates.
+    
+    AccruedInterestReceivableBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.AccruedInterestReceivableBalanceSheet:
+        pass
+
+    NineMonths: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class AccruedInvestmentIncomeBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Interest, dividends, rents, ancillary and other revenues earned but not yet received by the entity on its investments.
+    
+    AccruedInvestmentIncomeBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.AccruedInvestmentIncomeBalanceSheet:
+        pass
+
+    NineMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class AccruedLiabilitiesTotalBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Liabilities which have occurred, but have not been paid or logged under accounts payable during an accounting PeriodAsByte. In other
+                words, obligations for goods and services provided to a company for which invoices have not yet been received; on a Non-
+                Differentiated Balance Sheet.
+    
+    AccruedLiabilitiesTotalBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.AccruedLiabilitiesTotalBalanceSheet:
+        pass
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class AccumulatedDepreciationBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The cumulative amount of wear and tear or obsolescence charged against the fixed assets of a company.
+    
+    AccumulatedDepreciationBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.AccumulatedDepreciationBalanceSheet:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class AdditionalPaidInCapitalBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Excess of issue price over par or stated value of the entity's capital stock and amounts received from other transactions involving
+                the entity's stock or stockholders. Includes adjustments to additional paid in capital. There are two major categories of additional
+                paid in capital: 1) Paid in capital in excess of par/stated value, which is the difference between the actual issue price of the shares
+                and the shares' par/stated value. 2) Paid in capital from other transactions which includes treasury stock, retirement of stock, stock
+                dividends recorded at market, lapse of stock purchase warrants, conversion of convertible bonds in excess of the par value of the
+                stock, and any other additional capital from the company's own stock transactions.
+    
+    AdditionalPaidInCapitalBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.AdditionalPaidInCapitalBalanceSheet:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]

Algorithm.Python/stubs/QuantConnect/Data/Market.py

@@ -0,0 +1,335 @@
+from .__Market_1 import *
+import typing
+import System.IO
+import System.Collections.Generic
+import System
+import QuantConnect.Orders
+import QuantConnect.Data.Market
+import QuantConnect.Data
+import QuantConnect
+import datetime
+
+# no functions
+# classes
+
+class Bar(System.object, QuantConnect.Data.Market.IBar):
+    """
+    Base Bar Class: Open, High, Low, Close and Period.
+    
+    Bar()
+    Bar(open: Decimal, high: Decimal, low: Decimal, close: Decimal)
+    """
+    def Clone(self) -> QuantConnect.Data.Market.Bar:
+        pass
+
+    def ToString(self) -> str:
+        pass
+
+    @typing.overload
+    def Update(self, value: float) -> None:
+        pass
+
+    @typing.overload
+    def Update(self, value: float) -> None:
+        pass
+
+    def Update(self, *args) -> None:
+        pass
+
+    @typing.overload
+    def __init__(self) -> QuantConnect.Data.Market.Bar:
+        pass
+
+    @typing.overload
+    def __init__(self, open: float, high: float, low: float, close: float) -> QuantConnect.Data.Market.Bar:
+        pass
+
+    def __init__(self, *args) -> QuantConnect.Data.Market.Bar:
+        pass
+
+    Close: float
+
+    High: float
+
+    Low: float
+
+    Open: float
+
+
+
+class BarDirection(System.Enum, System.IConvertible, System.IFormattable, System.IComparable):
+    """ enum BarDirection, values: Falling (2), NoDelta (1), Rising (0) """
+    value__: int
+    Falling: 'BarDirection'
+    NoDelta: 'BarDirection'
+    Rising: 'BarDirection'
+
+
+class DataDictionary(QuantConnect.ExtendedDictionary[T], System.Collections.IEnumerable, QuantConnect.Interfaces.IExtendedDictionary[Symbol, T], System.Collections.Generic.ICollection[KeyValuePair[Symbol, T]], System.Collections.Generic.IDictionary[Symbol, T], System.Collections.Generic.IEnumerable[KeyValuePair[Symbol, T]]):
+    """
+    DataDictionary[T]()
+    DataDictionary[T](data: IEnumerable[T], keySelector: Func[T, Symbol])
+    DataDictionary[T](time: DateTime)
+    """
+    @typing.overload
+    def Add(self, item: System.Collections.Generic.KeyValuePair[QuantConnect.Symbol, QuantConnect.Data.Market.T]) -> None:
+        pass
+
+    @typing.overload
+    def Add(self, key: QuantConnect.Symbol, value: QuantConnect.Data.Market.T) -> None:
+        pass
+
+    def Add(self, *args) -> None:
+        pass
+
+    def Clear(self) -> None:
+        pass
+
+    def Contains(self, item: System.Collections.Generic.KeyValuePair[QuantConnect.Symbol, QuantConnect.Data.Market.T]) -> bool:
+        pass
+
+    def ContainsKey(self, key: QuantConnect.Symbol) -> bool:
+        pass
+
+    def CopyTo(self, array: typing.List[System.Collections.Generic.KeyValuePair], arrayIndex: int) -> None:
+        pass
+
+    def GetEnumerator(self) -> System.Collections.Generic.IEnumerator[System.Collections.Generic.KeyValuePair[QuantConnect.Symbol, QuantConnect.Data.Market.T]]:
+        pass
+
+    def GetValue(self, key: QuantConnect.Symbol) -> QuantConnect.Data.Market.T:
+        pass
+
+    @typing.overload
+    def Remove(self, item: System.Collections.Generic.KeyValuePair[QuantConnect.Symbol, QuantConnect.Data.Market.T]) -> bool:
+        pass
+
+    @typing.overload
+    def Remove(self, key: QuantConnect.Symbol) -> bool:
+        pass
+
+    def Remove(self, *args) -> bool:
+        pass
+
+    def TryGetValue(self, key: QuantConnect.Symbol, value: QuantConnect.Data.Market.T) -> bool:
+        pass
+
+    @typing.overload
+    def __init__(self) -> QuantConnect.Data.Market.DataDictionary:
+        pass
+
+    @typing.overload
+    def __init__(self, data: typing.List[QuantConnect.Data.Market.T], keySelector: typing.Callable[[QuantConnect.Data.Market.T], QuantConnect.Symbol]) -> QuantConnect.Data.Market.DataDictionary:
+        pass
+
+    @typing.overload
+    def __init__(self, time: datetime.datetime) -> QuantConnect.Data.Market.DataDictionary:
+        pass
+
+    def __init__(self, *args) -> QuantConnect.Data.Market.DataDictionary:
+        pass
+
+    Count: int
+
+    IsReadOnly: bool
+
+    Keys: typing.List[QuantConnect.Symbol]
+
+    Time: datetime.datetime
+
+    Values: typing.List[QuantConnect.Data.Market.T]
+
+
+    Item: indexer#
+
+
+class DataDictionaryExtensions(System.object):
+    """ Provides extension methods for the DataDictionary class """
+    @staticmethod
+    def Add(dictionary: QuantConnect.Data.Market.DataDictionary[QuantConnect.Data.Market.T], data: QuantConnect.Data.Market.T) -> None:
+        pass
+
+    __all__: list
+
+
+class Delisting(QuantConnect.Data.BaseData, QuantConnect.Data.IBaseData):
+    """
+    Delisting event of a security
+    
+    Delisting()
+    Delisting(symbol: Symbol, date: DateTime, price: Decimal, type: DelistingType)
+    """
+    @typing.overload
+    def Clone(self) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Clone(self, fillForward: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    def Clone(self, *args) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def GetSource(self, config: QuantConnect.Data.SubscriptionDataConfig, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.SubscriptionDataSource:
+        pass
+
+    @typing.overload
+    def GetSource(self, config: QuantConnect.Data.SubscriptionDataConfig, date: datetime.datetime, datafeed: QuantConnect.DataFeedEndpoint) -> str:
+        pass
+
+    def GetSource(self, *args) -> str:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, line: str, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, stream: System.IO.StreamReader, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, line: str, date: datetime.datetime, datafeed: QuantConnect.DataFeedEndpoint) -> QuantConnect.Data.BaseData:
+        pass
+
+    def Reader(self, *args) -> QuantConnect.Data.BaseData:
+        pass
+
+    def SetOrderTicket(self, ticket: QuantConnect.Orders.OrderTicket) -> None:
+        pass
+
+    def ToString(self) -> str:
+        pass
+
+    @typing.overload
+    def __init__(self) -> QuantConnect.Data.Market.Delisting:
+        pass
+
+    @typing.overload
+    def __init__(self, symbol: QuantConnect.Symbol, date: datetime.datetime, price: float, type: QuantConnect.DelistingType) -> QuantConnect.Data.Market.Delisting:
+        pass
+
+    def __init__(self, *args) -> QuantConnect.Data.Market.Delisting:
+        pass
+
+    Ticket: QuantConnect.Orders.OrderTicket
+
+    Type: QuantConnect.DelistingType
+
+
+
+class Delistings(QuantConnect.Data.Market.DataDictionary[Delisting], System.Collections.IEnumerable, QuantConnect.Interfaces.IExtendedDictionary[Symbol, Delisting], System.Collections.Generic.ICollection[KeyValuePair[Symbol, Delisting]], System.Collections.Generic.IDictionary[Symbol, Delisting], System.Collections.Generic.IEnumerable[KeyValuePair[Symbol, Delisting]]):
+    """
+    Collections of QuantConnect.Data.Market.Delisting keyed by QuantConnect.Symbol
+    
+    Delistings()
+    Delistings(frontier: DateTime)
+    """
+    @typing.overload
+    def __init__(self) -> QuantConnect.Data.Market.Delistings:
+        pass
+
+    @typing.overload
+    def __init__(self, frontier: datetime.datetime) -> QuantConnect.Data.Market.Delistings:
+        pass
+
+    def __init__(self, *args) -> QuantConnect.Data.Market.Delistings:
+        pass
+
+
+    Item: indexer#
+
+
+class Dividend(QuantConnect.Data.BaseData, QuantConnect.Data.IBaseData):
+    """
+    Dividend event from a security
+    
+    Dividend()
+    Dividend(symbol: Symbol, date: DateTime, distribution: Decimal, referencePrice: Decimal)
+    """
+    @typing.overload
+    def Clone(self) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Clone(self, fillForward: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    def Clone(self, *args) -> QuantConnect.Data.BaseData:
+        pass
+
+    @staticmethod
+    def ComputeDistribution(close: float, priceFactorRatio: float, decimalPlaces: int) -> float:
+        pass
+
+    @staticmethod
+    def Create(symbol: QuantConnect.Symbol, date: datetime.datetime, referencePrice: float, priceFactorRatio: float) -> QuantConnect.Data.Market.Dividend:
+        pass
+
+    @typing.overload
+    def GetSource(self, config: QuantConnect.Data.SubscriptionDataConfig, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.SubscriptionDataSource:
+        pass
+
+    @typing.overload
+    def GetSource(self, config: QuantConnect.Data.SubscriptionDataConfig, date: datetime.datetime, datafeed: QuantConnect.DataFeedEndpoint) -> str:
+        pass
+
+    def GetSource(self, *args) -> str:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, line: str, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, stream: System.IO.StreamReader, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, line: str, date: datetime.datetime, datafeed: QuantConnect.DataFeedEndpoint) -> QuantConnect.Data.BaseData:
+        pass
+
+    def Reader(self, *args) -> QuantConnect.Data.BaseData:
+        pass
+
+    def ToString(self) -> str:
+        pass
+
+    @typing.overload
+    def __init__(self) -> QuantConnect.Data.Market.Dividend:
+        pass
+
+    @typing.overload
+    def __init__(self, symbol: QuantConnect.Symbol, date: datetime.datetime, distribution: float, referencePrice: float) -> QuantConnect.Data.Market.Dividend:
+        pass
+
+    def __init__(self, *args) -> QuantConnect.Data.Market.Dividend:
+        pass
+
+    Distribution: float
+
+    ReferencePrice: float
+
+
+
+class Dividends(QuantConnect.Data.Market.DataDictionary[Dividend], System.Collections.IEnumerable, QuantConnect.Interfaces.IExtendedDictionary[Symbol, Dividend], System.Collections.Generic.ICollection[KeyValuePair[Symbol, Dividend]], System.Collections.Generic.IDictionary[Symbol, Dividend], System.Collections.Generic.IEnumerable[KeyValuePair[Symbol, Dividend]]):
+    """
+    Collection of dividends keyed by QuantConnect.Symbol
+    
+    Dividends()
+    Dividends(frontier: DateTime)
+    """
+    @typing.overload
+    def __init__(self) -> QuantConnect.Data.Market.Dividends:
+        pass
+
+    @typing.overload
+    def __init__(self, frontier: datetime.datetime) -> QuantConnect.Data.Market.Dividends:
+        pass
+
+    def __init__(self, *args) -> QuantConnect.Data.Market.Dividends:
+        pass
+
+
+    Item: indexer#

Algorithm.Python/stubs/QuantConnect/Data/UniverseSelection.py

@@ -0,0 +1,254 @@
+from .__UniverseSelection_1 import *
+import typing
+import System.IO
+import System.Collections.Generic
+import System.Collections.Concurrent
+import System
+import QuantConnect.Securities.Option
+import QuantConnect.Securities.Future
+import QuantConnect.Securities
+import QuantConnect.Scheduling
+import QuantConnect.Interfaces
+import QuantConnect.Data.UniverseSelection
+import QuantConnect.Data.Fundamental
+import QuantConnect.Data
+import QuantConnect
+import Python.Runtime
+import NodaTime
+import datetime
+
+# no functions
+# classes
+
+class BaseDataCollection(QuantConnect.Data.BaseData, QuantConnect.Data.IBaseData):
+    """
+    This type exists for transport of data as a single packet
+    
+    BaseDataCollection()
+    BaseDataCollection(time: DateTime, symbol: Symbol, data: IEnumerable[BaseData])
+    BaseDataCollection(time: DateTime, endTime: DateTime, symbol: Symbol, data: IEnumerable[BaseData])
+    BaseDataCollection(time: DateTime, endTime: DateTime, symbol: Symbol, data: List[BaseData])
+    """
+    @typing.overload
+    def Clone(self) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Clone(self, fillForward: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    def Clone(self, *args) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def __init__(self) -> QuantConnect.Data.UniverseSelection.BaseDataCollection:
+        pass
+
+    @typing.overload
+    def __init__(self, time: datetime.datetime, symbol: QuantConnect.Symbol, data: typing.List[QuantConnect.Data.BaseData]) -> QuantConnect.Data.UniverseSelection.BaseDataCollection:
+        pass
+
+    @typing.overload
+    def __init__(self, time: datetime.datetime, endTime: datetime.datetime, symbol: QuantConnect.Symbol, data: typing.List[QuantConnect.Data.BaseData]) -> QuantConnect.Data.UniverseSelection.BaseDataCollection:
+        pass
+
+    @typing.overload
+    def __init__(self, time: datetime.datetime, endTime: datetime.datetime, symbol: QuantConnect.Symbol, data: typing.List[QuantConnect.Data.BaseData]) -> QuantConnect.Data.UniverseSelection.BaseDataCollection:
+        pass
+
+    def __init__(self, *args) -> QuantConnect.Data.UniverseSelection.BaseDataCollection:
+        pass
+
+    Data: typing.List[QuantConnect.Data.BaseData]
+
+    EndTime: datetime.datetime
+
+
+
+class CoarseFundamental(QuantConnect.Data.BaseData, QuantConnect.Data.IBaseData):
+    """
+    Defines summary information about a single symbol for a given date
+    
+    CoarseFundamental()
+    """
+    @typing.overload
+    def Clone(self) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Clone(self, fillForward: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    def Clone(self, *args) -> QuantConnect.Data.BaseData:
+        pass
+
+    @staticmethod
+    def CreateUniverseSymbol(market: str, addGuid: bool) -> QuantConnect.Symbol:
+        pass
+
+    @typing.overload
+    def GetSource(self, config: QuantConnect.Data.SubscriptionDataConfig, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.SubscriptionDataSource:
+        pass
+
+    @typing.overload
+    def GetSource(self, config: QuantConnect.Data.SubscriptionDataConfig, date: datetime.datetime, datafeed: QuantConnect.DataFeedEndpoint) -> str:
+        pass
+
+    def GetSource(self, *args) -> str:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, line: str, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, stream: System.IO.StreamReader, date: datetime.datetime, isLiveMode: bool) -> QuantConnect.Data.BaseData:
+        pass
+
+    @typing.overload
+    def Reader(self, config: QuantConnect.Data.SubscriptionDataConfig, line: str, date: datetime.datetime, datafeed: QuantConnect.DataFeedEndpoint) -> QuantConnect.Data.BaseData:
+        pass
+
+    def Reader(self, *args) -> QuantConnect.Data.BaseData:
+        pass
+
+    AdjustedPrice: float
+
+    DollarVolume: float
+
+    EndTime: datetime.datetime
+
+    HasFundamentalData: bool
+
+    Market: str
+
+    PriceFactor: float
+
+    PriceScaleFactor: float
+
+    SplitFactor: float
+
+    Volume: int
+
+
+
+class Universe(System.object, System.IDisposable):
+    """ Provides a base class for all universes to derive from. """
+    def CanRemoveMember(self, utcTime: datetime.datetime, security: QuantConnect.Securities.Security) -> bool:
+        pass
+
+    def ContainsMember(self, symbol: QuantConnect.Symbol) -> bool:
+        pass
+
+    def CreateSecurity(self, symbol: QuantConnect.Symbol, algorithm: QuantConnect.Interfaces.IAlgorithm, marketHoursDatabase: QuantConnect.Securities.MarketHoursDatabase, symbolPropertiesDatabase: QuantConnect.Securities.SymbolPropertiesDatabase) -> QuantConnect.Securities.Security:
+        pass
+
+    def Dispose(self) -> None:
+        pass
+
+    @typing.overload
+    def GetSubscriptionRequests(self, security: QuantConnect.Securities.Security, currentTimeUtc: datetime.datetime, maximumEndTimeUtc: datetime.datetime) -> typing.List[QuantConnect.Data.UniverseSelection.SubscriptionRequest]:
+        pass
+
+    @typing.overload
+    def GetSubscriptionRequests(self, security: QuantConnect.Securities.Security, currentTimeUtc: datetime.datetime, maximumEndTimeUtc: datetime.datetime, subscriptionService: QuantConnect.Interfaces.ISubscriptionDataConfigService) -> typing.List[QuantConnect.Data.UniverseSelection.SubscriptionRequest]:
+        pass
+
+    def GetSubscriptionRequests(self, *args) -> typing.List[QuantConnect.Data.UniverseSelection.SubscriptionRequest]:
+        pass
+
+    def PerformSelection(self, utcTime: datetime.datetime, data: QuantConnect.Data.UniverseSelection.BaseDataCollection) -> typing.List[QuantConnect.Symbol]:
+        pass
+
+    def SelectSymbols(self, utcTime: datetime.datetime, data: QuantConnect.Data.UniverseSelection.BaseDataCollection) -> typing.List[QuantConnect.Symbol]:
+        pass
+
+    def SetSecurityInitializer(self, securityInitializer: QuantConnect.Securities.ISecurityInitializer) -> None:
+        pass
+
+    def __init__(self, *args): #cannot find CLR constructor
+        pass
+
+    Configuration: QuantConnect.Data.SubscriptionDataConfig
+
+    DisposeRequested: bool
+
+    Market: str
+
+    Members: System.Collections.Generic.Dictionary[QuantConnect.Symbol, QuantConnect.Securities.Security]
+
+    Securities: System.Collections.Concurrent.ConcurrentDictionary[QuantConnect.Symbol, QuantConnect.Data.UniverseSelection.Member]
+
+    SecurityInitializer: QuantConnect.Securities.ISecurityInitializer
+
+    SecurityType: QuantConnect.SecurityType
+
+    UniverseSettings: QuantConnect.Data.UniverseSelection.UniverseSettings
+
+
+    Member: type
+    Unchanged: UnchangedUniverse
+    UnchangedUniverse: type
+
+
+class CoarseFundamentalUniverse(QuantConnect.Data.UniverseSelection.Universe, System.IDisposable):
+    """
+    Defines a universe that reads coarse us equity data
+    
+    CoarseFundamentalUniverse(universeSettings: UniverseSettings, securityInitializer: ISecurityInitializer, selector: Func[IEnumerable[CoarseFundamental], IEnumerable[Symbol]])
+    CoarseFundamentalUniverse(universeSettings: UniverseSettings, securityInitializer: ISecurityInitializer, selector: PyObject)
+    CoarseFundamentalUniverse(symbol: Symbol, universeSettings: UniverseSettings, securityInitializer: ISecurityInitializer, selector: Func[IEnumerable[CoarseFundamental], IEnumerable[Symbol]])
+    CoarseFundamentalUniverse(symbol: Symbol, universeSettings: UniverseSettings, securityInitializer: ISecurityInitializer, selector: PyObject)
+    """
+    @staticmethod
+    def CreateConfiguration(symbol: QuantConnect.Symbol) -> QuantConnect.Data.SubscriptionDataConfig:
+        pass
+
+    def SelectSymbols(self, utcTime: datetime.datetime, data: QuantConnect.Data.UniverseSelection.BaseDataCollection) -> typing.List[QuantConnect.Symbol]:
+        pass
+
+    @typing.overload
+    def __init__(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings, securityInitializer: QuantConnect.Securities.ISecurityInitializer, selector: typing.Callable[[typing.List[QuantConnect.Data.UniverseSelection.CoarseFundamental]], typing.List[QuantConnect.Symbol]]) -> QuantConnect.Data.UniverseSelection.CoarseFundamentalUniverse:
+        pass
+
+    @typing.overload
+    def __init__(self, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings, securityInitializer: QuantConnect.Securities.ISecurityInitializer, selector: Python.Runtime.PyObject) -> QuantConnect.Data.UniverseSelection.CoarseFundamentalUniverse:
+        pass
+
+    @typing.overload
+    def __init__(self, symbol: QuantConnect.Symbol, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings, securityInitializer: QuantConnect.Securities.ISecurityInitializer, selector: typing.Callable[[typing.List[QuantConnect.Data.UniverseSelection.CoarseFundamental]], typing.List[QuantConnect.Symbol]]) -> QuantConnect.Data.UniverseSelection.CoarseFundamentalUniverse:
+        pass
+
+    @typing.overload
+    def __init__(self, symbol: QuantConnect.Symbol, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings, securityInitializer: QuantConnect.Securities.ISecurityInitializer, selector: Python.Runtime.PyObject) -> QuantConnect.Data.UniverseSelection.CoarseFundamentalUniverse:
+        pass
+
+    def __init__(self, *args) -> QuantConnect.Data.UniverseSelection.CoarseFundamentalUniverse:
+        pass
+
+    UniverseSettings: QuantConnect.Data.UniverseSelection.UniverseSettings
+
+
+
+class FuncUniverse(QuantConnect.Data.UniverseSelection.Universe, System.IDisposable):
+    """
+    Provides a functional implementation of QuantConnect.Data.UniverseSelection.Universe
+    
+    FuncUniverse(configuration: SubscriptionDataConfig, universeSettings: UniverseSettings, securityInitializer: ISecurityInitializer, universeSelector: Func[IEnumerable[BaseData], IEnumerable[Symbol]])
+    FuncUniverse(configuration: SubscriptionDataConfig, universeSettings: UniverseSettings, universeSelector: Func[IEnumerable[BaseData], IEnumerable[Symbol]])
+    """
+    def SelectSymbols(self, utcTime: datetime.datetime, data: QuantConnect.Data.UniverseSelection.BaseDataCollection) -> typing.List[QuantConnect.Symbol]:
+        pass
+
+    @typing.overload
+    def __init__(self, configuration: QuantConnect.Data.SubscriptionDataConfig, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings, securityInitializer: QuantConnect.Securities.ISecurityInitializer, universeSelector: typing.Callable[[typing.List[QuantConnect.Data.BaseData]], typing.List[QuantConnect.Symbol]]) -> QuantConnect.Data.UniverseSelection.FuncUniverse:
+        pass
+
+    @typing.overload
+    def __init__(self, configuration: QuantConnect.Data.SubscriptionDataConfig, universeSettings: QuantConnect.Data.UniverseSelection.UniverseSettings, universeSelector: typing.Callable[[typing.List[QuantConnect.Data.BaseData]], typing.List[QuantConnect.Symbol]]) -> QuantConnect.Data.UniverseSelection.FuncUniverse:
+        pass
+
+    def __init__(self, *args) -> QuantConnect.Data.UniverseSelection.FuncUniverse:
+        pass
+
+    UniverseSettings: QuantConnect.Data.UniverseSelection.UniverseSettings

Algorithm.Python/stubs/QuantConnect/Data/__Consolidators_1.py

@@ -0,0 +1,167 @@
+import typing
+import System
+import QuantConnect.Data.Market
+import QuantConnect.Data.Consolidators
+import QuantConnect.Data
+import QuantConnect
+import Python.Runtime
+import datetime
+
+
+
+class SequentialConsolidator(System.object, System.IDisposable, QuantConnect.Data.Consolidators.IDataConsolidator):
+    """
+    This consolidator wires up the events on its First and Second consolidators
+                such that data flows from the First to Second consolidator. It's output comes
+                from the Second.
+    
+    SequentialConsolidator(first: IDataConsolidator, second: IDataConsolidator)
+    """
+    def Dispose(self) -> None:
+        pass
+
+    def Scan(self, currentLocalTime: datetime.datetime) -> None:
+        pass
+
+    def Update(self, data: QuantConnect.Data.IBaseData) -> None:
+        pass
+
+    def __init__(self, first: QuantConnect.Data.Consolidators.IDataConsolidator, second: QuantConnect.Data.Consolidators.IDataConsolidator) -> QuantConnect.Data.Consolidators.SequentialConsolidator:
+        pass
+
+    Consolidated: QuantConnect.Data.IBaseData
+
+    First: QuantConnect.Data.Consolidators.IDataConsolidator
+
+    InputType: type
+
+    OutputType: type
+
+    Second: QuantConnect.Data.Consolidators.IDataConsolidator
+
+    WorkingData: QuantConnect.Data.IBaseData
+
+
+    DataConsolidated: BoundEvent
+
+
+class TickConsolidator(QuantConnect.Data.Consolidators.TradeBarConsolidatorBase[Tick], System.IDisposable, QuantConnect.Data.Consolidators.IDataConsolidator):
+    """
+    A data consolidator that can make bigger bars from ticks over a given
+                time span or a count of pieces of data.
+    
+    TickConsolidator(period: TimeSpan)
+    TickConsolidator(maxCount: int)
+    TickConsolidator(maxCount: int, period: TimeSpan)
+    TickConsolidator(func: Func[DateTime, CalendarInfo])
+    TickConsolidator(pyfuncobj: PyObject)
+    """
+    @typing.overload
+    def __init__(self, period: datetime.timedelta) -> QuantConnect.Data.Consolidators.TickConsolidator:
+        pass
+
+    @typing.overload
+    def __init__(self, maxCount: int) -> QuantConnect.Data.Consolidators.TickConsolidator:
+        pass
+
+    @typing.overload
+    def __init__(self, maxCount: int, period: datetime.timedelta) -> QuantConnect.Data.Consolidators.TickConsolidator:
+        pass
+
+    @typing.overload
+    def __init__(self, func: typing.Callable[[datetime.datetime], QuantConnect.Data.Consolidators.CalendarInfo]) -> QuantConnect.Data.Consolidators.TickConsolidator:
+        pass
+
+    @typing.overload
+    def __init__(self, pyfuncobj: Python.Runtime.PyObject) -> QuantConnect.Data.Consolidators.TickConsolidator:
+        pass
+
+    def __init__(self, *args) -> QuantConnect.Data.Consolidators.TickConsolidator:
+        pass
+
+
+
+class TickQuoteBarConsolidator(QuantConnect.Data.Consolidators.PeriodCountConsolidatorBase[Tick, QuoteBar], System.IDisposable, QuantConnect.Data.Consolidators.IDataConsolidator):
+    """
+    Consolidates ticks into quote bars. This consolidator ignores trade ticks
+    
+    TickQuoteBarConsolidator(period: TimeSpan)
+    TickQuoteBarConsolidator(maxCount: int)
+    TickQuoteBarConsolidator(maxCount: int, period: TimeSpan)
+    TickQuoteBarConsolidator(func: Func[DateTime, CalendarInfo])
+    TickQuoteBarConsolidator(pyfuncobj: PyObject)
+    """
+    @typing.overload
+    def __init__(self, period: datetime.timedelta) -> QuantConnect.Data.Consolidators.TickQuoteBarConsolidator:
+        pass
+
+    @typing.overload
+    def __init__(self, maxCount: int) -> QuantConnect.Data.Consolidators.TickQuoteBarConsolidator:
+        pass
+
+    @typing.overload
+    def __init__(self, maxCount: int, period: datetime.timedelta) -> QuantConnect.Data.Consolidators.TickQuoteBarConsolidator:
+        pass
+
+    @typing.overload
+    def __init__(self, func: typing.Callable[[datetime.datetime], QuantConnect.Data.Consolidators.CalendarInfo]) -> QuantConnect.Data.Consolidators.TickQuoteBarConsolidator:
+        pass
+
+    @typing.overload
+    def __init__(self, pyfuncobj: Python.Runtime.PyObject) -> QuantConnect.Data.Consolidators.TickQuoteBarConsolidator:
+        pass
+
+    def __init__(self, *args) -> QuantConnect.Data.Consolidators.TickQuoteBarConsolidator:
+        pass
+
+
+
+class TradeBarConsolidator(QuantConnect.Data.Consolidators.TradeBarConsolidatorBase[TradeBar], System.IDisposable, QuantConnect.Data.Consolidators.IDataConsolidator):
+    """
+    A data consolidator that can make bigger bars from smaller ones over a given
+                 time span or a count of pieces of data.
+                
+                 Use this consolidator to turn data of a lower resolution into data of a higher resolution,
+                 for example, if you subscribe to minute data but want to have a 15 minute bar.
+    
+    TradeBarConsolidator(period: TimeSpan)
+    TradeBarConsolidator(maxCount: int)
+    TradeBarConsolidator(maxCount: int, period: TimeSpan)
+    TradeBarConsolidator(func: Func[DateTime, CalendarInfo])
+    TradeBarConsolidator(pyfuncobj: PyObject)
+    """
+    @staticmethod
+    def FromResolution(resolution: QuantConnect.Resolution) -> QuantConnect.Data.Consolidators.TradeBarConsolidator:
+        pass
+
+    @typing.overload
+    def __init__(self, period: datetime.timedelta) -> QuantConnect.Data.Consolidators.TradeBarConsolidator:
+        pass
+
+    @typing.overload
+    def __init__(self, maxCount: int) -> QuantConnect.Data.Consolidators.TradeBarConsolidator:
+        pass
+
+    @typing.overload
+    def __init__(self, maxCount: int, period: datetime.timedelta) -> QuantConnect.Data.Consolidators.TradeBarConsolidator:
+        pass
+
+    @typing.overload
+    def __init__(self, func: typing.Callable[[datetime.datetime], QuantConnect.Data.Consolidators.CalendarInfo]) -> QuantConnect.Data.Consolidators.TradeBarConsolidator:
+        pass
+
+    @typing.overload
+    def __init__(self, pyfuncobj: Python.Runtime.PyObject) -> QuantConnect.Data.Consolidators.TradeBarConsolidator:
+        pass
+
+    def __init__(self, *args) -> QuantConnect.Data.Consolidators.TradeBarConsolidator:
+        pass
+
+
+
+class TradeBarConsolidatorBase(QuantConnect.Data.Consolidators.PeriodCountConsolidatorBase[T, TradeBar], System.IDisposable, QuantConnect.Data.Consolidators.IDataConsolidator):
+    # no doc
+    def __init__(self, *args): #cannot find CLR constructor
+        pass
+
+    WorkingBar: QuantConnect.Data.Market.TradeBar

Algorithm.Python/stubs/QuantConnect/Data/__Fundamental_1.py

@@ -0,0 +1,316 @@
+from .__Fundamental_2 import *
+import typing
+import System.IO
+import System.Collections.Generic
+import System
+import QuantConnect.Data.Fundamental.MultiPeriodField
+import QuantConnect.Data.Fundamental
+import QuantConnect.Data
+import QuantConnect
+import datetime
+
+
+class AdvanceFromFederalHomeLoanBanksBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    This item is typically available for bank industry. It's the amount of borrowings as of the balance sheet date from the Federal Home
+                Loan Bank, which are primarily used to cover shortages in the required reserve balance and liquidity shortages.
+    
+    AdvanceFromFederalHomeLoanBanksBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.AdvanceFromFederalHomeLoanBanksBalanceSheet:
+        pass
+
+    NineMonths: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class AdvancesfromCentralBanksBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Borrowings from the central bank, which are primarily used to cover shortages in the required reserve balance and liquidity
+                shortages.
+    
+    AdvancesfromCentralBanksBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.AdvancesfromCentralBanksBalanceSheet:
+        pass
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class AllowanceForDoubtfulAccountsReceivableBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    An Allowance for Doubtful Accounts measures receivables recorded but not expected to be collected.
+    
+    AllowanceForDoubtfulAccountsReceivableBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.AllowanceForDoubtfulAccountsReceivableBalanceSheet:
+        pass
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class AllowanceForLoansAndLeaseLossesBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    A contra account sets aside as an allowance for bad loans (e.g. customer defaults).
+    
+    AllowanceForLoansAndLeaseLossesBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.AllowanceForLoansAndLeaseLossesBalanceSheet:
+        pass
+
+    NineMonths: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class AllowanceForNotesReceivableBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    This item is typically available for bank industry. It represents a provision relating to a written agreement to receive money  with the
+                terms of the note (at a specified future date(s) within one year from the reporting date (or the normal operating cycle, whichever is
+                longer), consisting of principal as well as any accrued interest) for the portion that is expected to be uncollectible.
+    
+    AllowanceForNotesReceivableBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.AllowanceForNotesReceivableBalanceSheet:
+        pass
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class AllTaxesPaidCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Cash paid to tax authorities in operating cash flow, using the direct method
+    
+    AllTaxesPaidCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.AllTaxesPaidCashFlowStatement:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class AmortizationCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The systematic and rational apportionment of the acquisition cost of intangible operational assets to future periods in which the benefits
+                contribute to revenue. This field is to include Amortization and any variation where Amortization is the first account listed in the line item,
+                excluding Amortization of Intangibles.
+    
+    AmortizationCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.AmortizationCashFlowStatement:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class AmortizationIncomeStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The non-cash expense recognized on intangible assets over the benefit period of the asset.
+    
+    AmortizationIncomeStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.AmortizationIncomeStatement:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class AmortizationOfFinancingCostsAndDiscountsCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The component of interest expense representing the non-cash expenses charged against earnings in the period to allocate debt
+                discount and premium, and the costs to issue debt and obtain financing over the related debt instruments. This item is usually only
+                available for bank industry.
+    
+    AmortizationOfFinancingCostsAndDiscountsCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.AmortizationOfFinancingCostsAndDiscountsCashFlowStatement:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class AmortizationOfIntangiblesCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The aggregate expense charged against earnings to allocate the cost of intangible assets (nonphysical assets not used in
+                production) in a systematic and rational manner to the periods expected to benefit from such assets.
+    
+    AmortizationOfIntangiblesCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.AmortizationOfIntangiblesCashFlowStatement:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class AmortizationOfIntangiblesIncomeStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The aggregate expense charged against earnings to allocate the cost of intangible assets (nonphysical assets not used in
+                production) in a systematic and rational manner to the periods expected to benefit from such assets.
+    
+    AmortizationOfIntangiblesIncomeStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.AmortizationOfIntangiblesIncomeStatement:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]

Algorithm.Python/stubs/QuantConnect/Data/__Fundamental_10.py

@@ -0,0 +1,330 @@
+from .__Fundamental_11 import *
+import typing
+import System.IO
+import System.Collections.Generic
+import System
+import QuantConnect.Data.Fundamental.MultiPeriodField
+import QuantConnect.Data.Fundamental
+import QuantConnect.Data
+import QuantConnect
+import datetime
+
+
+class ChangeInAccountPayableCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The increase or decrease between periods of the account payables.
+    
+    ChangeInAccountPayableCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.ChangeInAccountPayableCashFlowStatement:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class ChangeInAccruedExpenseCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The increase or decrease between periods of the accrued expenses.
+    
+    ChangeInAccruedExpenseCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.ChangeInAccruedExpenseCashFlowStatement:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class ChangeinAccruedIncomeCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The increase or decrease between periods in the amount of outstanding money owed by a customer for goods or services provided
+                by the company.
+    
+    ChangeinAccruedIncomeCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.ChangeinAccruedIncomeCashFlowStatement:
+        pass
+
+    NineMonths: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class ChangeInAccruedInvestmentIncomeCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The net change during the reporting period in investment income that has been earned but not yet received in cash.
+    
+    ChangeInAccruedInvestmentIncomeCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.ChangeInAccruedInvestmentIncomeCashFlowStatement:
+        pass
+
+    NineMonths: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class ChangeinAdvancesfromCentralBanksCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The increase or decrease between periods of the advances from central banks.
+    
+    ChangeinAdvancesfromCentralBanksCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.ChangeinAdvancesfromCentralBanksCashFlowStatement:
+        pass
+
+    NineMonths: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class ChangeinCashSupplementalAsReportedCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The change in cash flow from the previous period to the current, as reported by the company, may be the same or not the same as
+                Morningstar's standardized definition. It is a supplemental value which would be reported outside consolidated statements.
+    
+    ChangeinCashSupplementalAsReportedCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.ChangeinCashSupplementalAsReportedCashFlowStatement:
+        pass
+
+    NineMonths: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class ChangeInDeferredAcquisitionCostsCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The change of the unamortized portion as of the balance sheet date of capitalized costs that vary with and are primarily related to
+                the acquisition of new and renewal insurance contracts.
+    
+    ChangeInDeferredAcquisitionCostsCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.ChangeInDeferredAcquisitionCostsCashFlowStatement:
+        pass
+
+    NineMonths: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class ChangeinDeferredAcquisitionCostsNetCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The increase or decrease between periods of the deferred acquisition costs.
+    
+    ChangeinDeferredAcquisitionCostsNetCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.ChangeinDeferredAcquisitionCostsNetCashFlowStatement:
+        pass
+
+    NineMonths: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class ChangeInDeferredChargesCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The net change during the reporting period in the value of expenditures made during the current reporting period for benefits that
+                will be received over a period of years. This item is usually only available for bank industry.
+    
+    ChangeInDeferredChargesCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.ChangeInDeferredChargesCashFlowStatement:
+        pass
+
+    NineMonths: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class ChangeinDepositsbyBanksandCustomersCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The increase or decrease between periods of the deposits by banks and customers.
+    
+    ChangeinDepositsbyBanksandCustomersCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.ChangeinDepositsbyBanksandCustomersCashFlowStatement:
+        pass
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class ChangeInDividendPayableCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The increase or decrease between periods of the dividend payables.
+    
+    ChangeInDividendPayableCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.ChangeInDividendPayableCashFlowStatement:
+        pass
+
+    NineMonths: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class ChangeInFederalFundsAndSecuritiesSoldForRepurchaseCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The amount shown on the books that a bank with insufficient reserves borrows, at the federal funds rate, from another bank to
+                meet its reserve requirements and the amount of securities that an institution sells and agrees to repurchase at a specified date for
+                a specified price, net of any reductions or offsets.
+    
+    ChangeInFederalFundsAndSecuritiesSoldForRepurchaseCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.ChangeInFederalFundsAndSecuritiesSoldForRepurchaseCashFlowStatement:
+        pass
+
+    NineMonths: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]

Algorithm.Python/stubs/QuantConnect/Data/__Fundamental_11.py

@@ -0,0 +1,357 @@
+from .__Fundamental_12 import *
+import typing
+import System.IO
+import System.Collections.Generic
+import System
+import QuantConnect.Data.Fundamental.MultiPeriodField
+import QuantConnect.Data.Fundamental
+import QuantConnect.Data
+import QuantConnect
+import datetime
+
+
+class ChangeinFinancialAssetsCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The increase or decrease between periods of the financial assets.
+    
+    ChangeinFinancialAssetsCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.ChangeinFinancialAssetsCashFlowStatement:
+        pass
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class ChangeinFinancialLiabilitiesCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The increase or decrease between periods of the financial liabilities.
+    
+    ChangeinFinancialLiabilitiesCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.ChangeinFinancialLiabilitiesCashFlowStatement:
+        pass
+
+    NineMonths: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class ChangeInFundsWithheldCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The net change during the reporting period associated with funds withheld.
+    
+    ChangeInFundsWithheldCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.ChangeInFundsWithheldCashFlowStatement:
+        pass
+
+    NineMonths: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class ChangeInIncomeTaxPayableCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The increase or decrease between periods of the income tax payables.
+    
+    ChangeInIncomeTaxPayableCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.ChangeInIncomeTaxPayableCashFlowStatement:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class ChangeinInsuranceContractAssetsCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The increase or decrease between periods of the contract assets.
+    
+    ChangeinInsuranceContractAssetsCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.ChangeinInsuranceContractAssetsCashFlowStatement:
+        pass
+
+    NineMonths: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class ChangeinInsuranceContractLiabilitiesCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The increase or decrease between periods of the insurance contract liabilities.
+    
+    ChangeinInsuranceContractLiabilitiesCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.ChangeinInsuranceContractLiabilitiesCashFlowStatement:
+        pass
+
+    NineMonths: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class ChangeinInsuranceFundsCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The increase or decrease between periods of the insurance funds.
+    
+    ChangeinInsuranceFundsCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.ChangeinInsuranceFundsCashFlowStatement:
+        pass
+
+    NineMonths: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class ChangeinInsuranceLiabilitiesNetofReinsuranceIncomeStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Income/Expense due to changes between periods in insurance liabilities.
+    
+    ChangeinInsuranceLiabilitiesNetofReinsuranceIncomeStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.ChangeinInsuranceLiabilitiesNetofReinsuranceIncomeStatement:
+        pass
+
+    NineMonths: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class ChangeInInterestPayableCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The increase or decrease between periods of the interest payable. Interest payable means carrying value as of the balance sheet
+                date of interest payable on all forms of debt.
+    
+    ChangeInInterestPayableCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.ChangeInInterestPayableCashFlowStatement:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class ChangeInInventoryCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The increase or decrease between periods of the Inventories. Inventories represent merchandise bought for resale and supplies and
+                raw materials purchased for use in revenue producing operations.
+    
+    ChangeInInventoryCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.ChangeInInventoryCashFlowStatement:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class ChangeinInvestmentContractIncomeStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Income/Expense due to changes between periods in Investment Contracts.
+    
+    ChangeinInvestmentContractIncomeStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.ChangeinInvestmentContractIncomeStatement:
+        pass
+
+    NineMonths: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class ChangeinInvestmentContractLiabilitiesCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The increase or decrease between periods of the investment contract liabilities.
+    
+    ChangeinInvestmentContractLiabilitiesCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.ChangeinInvestmentContractLiabilitiesCashFlowStatement:
+        pass
+
+    NineMonths: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class ChangeInLoansCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The net change that a lender gives money or property to a borrower and the borrower agrees to return the property or repay the
+                borrowed money, along with interest, at a predetermined date in the future.
+    
+    ChangeInLoansCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.ChangeInLoansCashFlowStatement:
+        pass
+
+    NineMonths: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]

Algorithm.Python/stubs/QuantConnect/Data/__Fundamental_12.py

@@ -0,0 +1,358 @@
+from .__Fundamental_13 import *
+import typing
+import System.IO
+import System.Collections.Generic
+import System
+import QuantConnect.Data.Fundamental.MultiPeriodField
+import QuantConnect.Data.Fundamental
+import QuantConnect.Data
+import QuantConnect
+import datetime
+
+
+class ChangeInLossAndLossAdjustmentExpenseReservesCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The net change during the reporting period in the reserve account established to account for expected but unspecified losses.
+    
+    ChangeInLossAndLossAdjustmentExpenseReservesCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.ChangeInLossAndLossAdjustmentExpenseReservesCashFlowStatement:
+        pass
+
+    NineMonths: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class ChangeInOtherCurrentAssetsCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The increase or decrease between periods of the Other Current Assets. This category typically includes prepayments, deferred
+                charges, and amounts (other than trade accounts) due from parents and subsidiaries.
+    
+    ChangeInOtherCurrentAssetsCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.ChangeInOtherCurrentAssetsCashFlowStatement:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class ChangeInOtherCurrentLiabilitiesCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The increase or decrease between periods of the Other Current liabilities. Other Current liabilities is a balance sheet entry used by
+                companies to group together current liabilities that are not assigned to common liabilities such as debt obligations or accounts
+                payable.
+    
+    ChangeInOtherCurrentLiabilitiesCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.ChangeInOtherCurrentLiabilitiesCashFlowStatement:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class ChangeInOtherWorkingCapitalCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The increase or decrease between periods of the other working capital.
+    
+    ChangeInOtherWorkingCapitalCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.ChangeInOtherWorkingCapitalCashFlowStatement:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class ChangeInPayableCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The increase or decrease between periods of the payables.
+    
+    ChangeInPayableCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.ChangeInPayableCashFlowStatement:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class ChangeInPayablesAndAccruedExpenseCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The increase or decrease between periods of the payables and accrued expenses. Accrued expenses represent expenses incurred
+                at the end of the reporting period but not yet paid; also called accrued liabilities. The accrued liability is shown under current
+                liabilities in the balance sheet.
+    
+    ChangeInPayablesAndAccruedExpenseCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.ChangeInPayablesAndAccruedExpenseCashFlowStatement:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class ChangeInPrepaidAssetsCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The increase or decrease between periods of the prepaid assets.
+    
+    ChangeInPrepaidAssetsCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.ChangeInPrepaidAssetsCashFlowStatement:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class ChangeInReceivablesCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The increase or decrease between periods of the receivables. Receivables are amounts due to be paid to the company from clients
+                and other.
+    
+    ChangeInReceivablesCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.ChangeInReceivablesCashFlowStatement:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class ChangeinReinsuranceReceivablesCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The increase or decrease between periods of the reinsurance receivable.
+    
+    ChangeinReinsuranceReceivablesCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.ChangeinReinsuranceReceivablesCashFlowStatement:
+        pass
+
+    NineMonths: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class ChangeInReinsuranceRecoverableOnPaidAndUnpaidLossesCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The net change during the reporting period in the amount of benefits the ceding insurer expects to recover on insurance policies
+                ceded to other insurance entities as of the balance sheet date for all guaranteed benefit types.
+    
+    ChangeInReinsuranceRecoverableOnPaidAndUnpaidLossesCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.ChangeInReinsuranceRecoverableOnPaidAndUnpaidLossesCashFlowStatement:
+        pass
+
+    NineMonths: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class ChangeInRestrictedCashCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The net cash inflow (outflow) for the net change associated with funds that are not available for withdrawal or use (such as funds
+                held in escrow).
+    
+    ChangeInRestrictedCashCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.ChangeInRestrictedCashCashFlowStatement:
+        pass
+
+    SixMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class ChangeInTaxPayableCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The increase or decrease between periods of the tax payables.
+    
+    ChangeInTaxPayableCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.ChangeInTaxPayableCashFlowStatement:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]

Algorithm.Python/stubs/QuantConnect/Data/__Fundamental_13.py

@@ -0,0 +1,337 @@
+from .__Fundamental_14 import *
+import typing
+import System.IO
+import System.Collections.Generic
+import System
+import QuantConnect.Data.Fundamental.MultiPeriodField
+import QuantConnect.Data.Fundamental
+import QuantConnect.Data
+import QuantConnect
+import datetime
+
+
+class ChangeinTheGrossProvisionforUnearnedPremiumsIncomeStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The change in the amount of the unearned premium reserves maintained by insurers.
+    
+    ChangeinTheGrossProvisionforUnearnedPremiumsIncomeStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.ChangeinTheGrossProvisionforUnearnedPremiumsIncomeStatement:
+        pass
+
+    NineMonths: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class ChangeinTheGrossProvisionforUnearnedPremiumsReinsurersShareIncomeStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The change in the amount of unearned premium reserve to be covered by reinsurers.
+    
+    ChangeinTheGrossProvisionforUnearnedPremiumsReinsurersShareIncomeStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.ChangeinTheGrossProvisionforUnearnedPremiumsReinsurersShareIncomeStatement:
+        pass
+
+    NineMonths: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class ChangeInTradingAccountSecuritiesCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The net change during the reporting period associated with trading account assets. Trading account assets are bought and held
+                principally for the purpose of selling them in the near term (thus held for only a short period of time). Unrealized holding gains and
+                losses for trading securities are included in earnings.
+    
+    ChangeInTradingAccountSecuritiesCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.ChangeInTradingAccountSecuritiesCashFlowStatement:
+        pass
+
+    NineMonths: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class ChangeInUnearnedPremiumsCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The change during the period in the unearned portion of premiums written, excluding the portion amortized into income. This item is
+                usually only available for insurance industry.
+    
+    ChangeInUnearnedPremiumsCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.ChangeInUnearnedPremiumsCashFlowStatement:
+        pass
+
+    NineMonths: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class ChangeInWorkingCapitalCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The increase or decrease between periods of the working capital.  Working Capital is the amount left to the company to finance
+                operations and expansion after current liabilities have been covered.
+    
+    ChangeInWorkingCapitalCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.ChangeInWorkingCapitalCashFlowStatement:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class ChangesInAccountReceivablesCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The increase or decrease between periods of the accounts receivables.
+    
+    ChangesInAccountReceivablesCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.ChangesInAccountReceivablesCashFlowStatement:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class ChangesInCashCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The net change between the beginning and ending balance of cash and cash equivalents.
+    
+    ChangesInCashCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.ChangesInCashCashFlowStatement:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class ClaimsandChangeinInsuranceLiabilitiesIncomeStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Income/Expense due to the insurer's changes in insurance liabilities.
+    
+    ClaimsandChangeinInsuranceLiabilitiesIncomeStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.ClaimsandChangeinInsuranceLiabilitiesIncomeStatement:
+        pass
+
+    NineMonths: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class ClaimsandPaidIncurredIncomeStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    All reported claims arising out of incidents in that year are considered incurred grouped with claims paid out.
+    
+    ClaimsandPaidIncurredIncomeStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.ClaimsandPaidIncurredIncomeStatement:
+        pass
+
+    NineMonths: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class ClaimsOutstandingBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Amounts owing to policy holders who have filed claims but have not yet been settled or paid.
+    
+    ClaimsOutstandingBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.ClaimsOutstandingBalanceSheet:
+        pass
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class ClaimsPaidCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Cash paid out for claims by a insurance company during the period in operating cash flow, using the direct method. This item is
+                usually only available for insurance industry
+    
+    ClaimsPaidCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.ClaimsPaidCashFlowStatement:
+        pass
+
+    NineMonths: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class ClassesofCashPaymentsCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Sum of total cash payment in the direct cash flow.
+    
+    ClassesofCashPaymentsCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.ClassesofCashPaymentsCashFlowStatement:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]

Algorithm.Python/stubs/QuantConnect/Data/__Fundamental_14.py

@@ -0,0 +1,420 @@
+from .__Fundamental_15 import *
+import typing
+import System.IO
+import System.Collections.Generic
+import System
+import QuantConnect.Data.Fundamental.MultiPeriodField
+import QuantConnect.Data.Fundamental
+import QuantConnect.Data
+import QuantConnect
+import datetime
+
+
+class ClassesofCashReceiptsfromOperatingActivitiesCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Sum of total cash receipts in the direct cash flow.
+    
+    ClassesofCashReceiptsfromOperatingActivitiesCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.ClassesofCashReceiptsfromOperatingActivitiesCashFlowStatement:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class CommercialLoanBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Short-term loan, typically 90 days, used by a company to finance seasonal working capital needs.
+    
+    CommercialLoanBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.CommercialLoanBalanceSheet:
+        pass
+
+    NineMonths: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class CommercialPaperBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Commercial paper is a money-market security issued by large banks and corporations. It represents the current obligation for the
+                company. There are four basic kinds of commercial paper: promissory notes, drafts, checks, and certificates of deposit. The
+                maturities of these money market securities generally do not exceed 270 days.
+    
+    CommercialPaperBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.CommercialPaperBalanceSheet:
+        pass
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class CommissionExpensesIncomeStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """ CommissionExpensesIncomeStatement(store: IDictionary[str, Decimal]) """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.CommissionExpensesIncomeStatement:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class CommissionPaidCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Cash paid for commissions in operating cash flow, using the direct method
+    
+    CommissionPaidCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.CommissionPaidCashFlowStatement:
+        pass
+
+    NineMonths: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class CommonEquityToAssets(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    This is a financial ratio of common stock equity to total assets that indicates the relative proportion of equity used to finance a
+                company's assets.
+    
+    CommonEquityToAssets(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.CommonEquityToAssets:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    OneYear: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class CommonStockBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Common stock (all issues) at par value, as reported within the Stockholder's Equity section of the balance sheet; i.e. it is one
+                component of Common Stockholder's Equity
+    
+    CommonStockBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.CommonStockBalanceSheet:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class CommonStockDividendPaidCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The cash outflow from the distribution of an entity's earnings in the form of dividends to common shareholders.
+    
+    CommonStockDividendPaidCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.CommonStockDividendPaidCashFlowStatement:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class CommonStockEquityBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The portion of the Stockholders' Equity that reflects the amount of common stock, which are units of ownership.
+    
+    CommonStockEquityBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.CommonStockEquityBalanceSheet:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class CommonStockIssuanceCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The cash inflow from offering common stock, which is the additional capital contribution to the entity during the PeriodAsByte.
+    
+    CommonStockIssuanceCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.CommonStockIssuanceCashFlowStatement:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class CommonStockPaymentsCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The cash outflow to reacquire common stock during the PeriodAsByte.
+    
+    CommonStockPaymentsCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.CommonStockPaymentsCashFlowStatement:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class CommonUtilityPlantBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The amount for the other plant related to the utility industry fix assets.
+    
+    CommonUtilityPlantBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.CommonUtilityPlantBalanceSheet:
+        pass
+
+    NineMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class CompanyProfile(System.object):
+    """
+    Definition of the CompanyProfile class
+    
+    CompanyProfile()
+    """
+    def UpdateValues(self, update: QuantConnect.Data.Fundamental.CompanyProfile) -> None:
+        pass
+
+    AverageEmployeeNumber: int
+
+    ContactEmail: str
+
+    EnterpriseValue: int
+
+    HeadquarterAddressLine1: str
+
+    HeadquarterAddressLine2: str
+
+    HeadquarterAddressLine3: str
+
+    HeadquarterAddressLine4: str
+
+    HeadquarterAddressLine5: str
+
+    HeadquarterCity: str
+
+    HeadquarterCountry: str
+
+    HeadquarterFax: str
+
+    HeadquarterHomepage: str
+
+    HeadquarterPhone: str
+
+    HeadquarterPostalCode: str
+
+    HeadquarterProvince: str
+
+    IsHeadOfficeSameWithRegisteredOfficeFlag: bool
+
+    MarketCap: int
+
+    ReasonofSharesChange: str
+
+    RegisteredAddressLine1: str
+
+    RegisteredAddressLine2: str
+
+    RegisteredAddressLine3: str
+
+    RegisteredAddressLine4: str
+
+    RegisteredCity: str
+
+    RegisteredCountry: str
+
+    RegisteredFax: str
+
+    RegisteredPhone: str
+
+    RegisteredPostalCode: str
+
+    RegisteredProvince: str
+
+    ShareClassLevelSharesOutstanding: int
+
+    SharesOutstanding: int
+
+    SharesOutstandingWithBalanceSheetEndingDate: int
+
+    TotalEmployeeNumber: int

Algorithm.Python/stubs/QuantConnect/Data/__Fundamental_15.py

@@ -0,0 +1,371 @@
+from .__Fundamental_16 import *
+import typing
+import System.IO
+import System.Collections.Generic
+import System
+import QuantConnect.Data.Fundamental.MultiPeriodField
+import QuantConnect.Data.Fundamental
+import QuantConnect.Data
+import QuantConnect
+import datetime
+
+
+
+class CompanyReference(System.object):
+    """
+    Definition of the CompanyReference class
+    
+    CompanyReference()
+    """
+    def UpdateValues(self, update: QuantConnect.Data.Fundamental.CompanyReference) -> None:
+        pass
+
+    Advisor: str
+
+    AdvisorLanguageCode: str
+
+    Auditor: str
+
+    AuditorLanguageCode: str
+
+    BusinessCountryID: str
+
+    CIK: str
+
+    CompanyId: str
+
+    CompanyStatus: str
+
+    CountryId: str
+
+    ExpectedFiscalYearEnd: datetime.datetime
+
+    FiscalYearEnd: int
+
+    IndustryTemplateCode: str
+
+    IsLimitedLiabilityCompany: bool
+
+    IsLimitedPartnership: bool
+
+    IsREIT: bool
+
+    LegalName: str
+
+    LegalNameLanguageCode: str
+
+    PrimaryExchangeID: str
+
+    PrimaryMIC: str
+
+    PrimaryShareClassID: str
+
+    PrimarySymbol: str
+
+    ReportStyle: int
+
+    ShortName: str
+
+    StandardName: str
+
+    YearofEstablishment: str
+
+
+
+class ComTreShaNumBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The treasury stock number of common shares. This represents the number of common shares owned by the company as a result of
+                share repurchase programs or donations.
+    
+    ComTreShaNumBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.ComTreShaNumBalanceSheet:
+        pass
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class ConstructionInProgressBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    It represents carrying amount of long-lived asset under construction that includes construction costs to date on capital projects.
+                Assets constructed, but not completed.
+    
+    ConstructionInProgressBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.ConstructionInProgressBalanceSheet:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class ConsumerLoanBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    A loan that establishes consumer credit that is granted for personal use; usually unsecured and based on the borrower's integrity
+                and ability to pay.
+    
+    ConsumerLoanBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.ConsumerLoanBalanceSheet:
+        pass
+
+    NineMonths: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class ContinuingAndDiscontinuedBasicEPS(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Basic EPS from Continuing Operations plus Basic EPS from Discontinued Operations.
+    
+    ContinuingAndDiscontinuedBasicEPS(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.ContinuingAndDiscontinuedBasicEPS:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class ContinuingAndDiscontinuedDilutedEPS(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Diluted EPS from Continuing Operations plus Diluted EPS from Discontinued Operations.
+    
+    ContinuingAndDiscontinuedDilutedEPS(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.ContinuingAndDiscontinuedDilutedEPS:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class ConvertibleLoansCurrentBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    This represents loans that entitle the lender (or the holder of loan debenture) to convert the loan to common or preferred stock
+                (ordinary or preference shares) within the next 12 months or operating cycle.
+    
+    ConvertibleLoansCurrentBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.ConvertibleLoansCurrentBalanceSheet:
+        pass
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class ConvertibleLoansNonCurrentBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    A long term loan with a warrant attached that gives the debt holder the option to exchange all or a portion of the loan principal for
+                an equity position in the company at a predetermined rate of conversion within a specified period of time.
+    
+    ConvertibleLoansNonCurrentBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.ConvertibleLoansNonCurrentBalanceSheet:
+        pass
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class ConvertibleLoansTotalBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Loans that entitles the lender (or the holder of loan debenture) to convert the loan to common or preferred stock (ordinary or
+                preference shares) at a specified rate conversion rate and a specified time frame; in a Non-Differentiated Balance Sheet.
+    
+    ConvertibleLoansTotalBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.ConvertibleLoansTotalBalanceSheet:
+        pass
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class CostOfRevenueIncomeStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The aggregate cost of goods produced and sold and services rendered during the reporting PeriodAsByte. It excludes all operating
+                expenses such as depreciation, depletion, amortization, and SG&A. For the must have cost industry, if the number is not reported
+                by the company, it will be calculated based on accounting equation.
+                Cost of Revenue = Revenue - Operating Expenses - Operating Profit.
+    
+    CostOfRevenueIncomeStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.CostOfRevenueIncomeStatement:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class CreditCardIncomeStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Income earned from credit card services including late, over limit, and annual fees. This item is usually only available for bank
+                industry.
+    
+    CreditCardIncomeStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.CreditCardIncomeStatement:
+        pass
+
+    NineMonths: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class CreditLossesProvisionIncomeStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    A charge to income which represents an expense deemed adequate by management given the composition of a bank's credit
+                portfolios, their probability of default, the economic environment and the allowance for credit losses already established. Specific
+                provisions are established to reduce the book value of specific assets (primarily loans) to establish the amount expected to be
+                recovered on the loans.
+    
+    CreditLossesProvisionIncomeStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.CreditLossesProvisionIncomeStatement:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]

Algorithm.Python/stubs/QuantConnect/Data/__Fundamental_16.py

@@ -0,0 +1,347 @@
+from .__Fundamental_17 import *
+import typing
+import System.IO
+import System.Collections.Generic
+import System
+import QuantConnect.Data.Fundamental.MultiPeriodField
+import QuantConnect.Data.Fundamental
+import QuantConnect.Data
+import QuantConnect
+import datetime
+
+
+class CreditRiskProvisionsIncomeStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Provision for the risk of loss of principal or loss of a financial reward stemming from a borrower's failure to repay a loan or otherwise
+                meet a contractual obligation. Credit risk arises whenever a borrower is expecting to use future cash flows to pay a current debt.
+                Investors are compensated for assuming credit risk by way of interest payments from the borrower or issuer of a debt obligation.
+                This is a contra account under Total Revenue in banks.
+    
+    CreditRiskProvisionsIncomeStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.CreditRiskProvisionsIncomeStatement:
+        pass
+
+    NineMonths: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class CurrentAccruedExpensesBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    An expense recognized before it is paid for. Includes compensation, interest, pensions and all other miscellaneous accruals
+                reported by the company. Expenses incurred during the accounting period, but not required to be paid until a later date.
+    
+    CurrentAccruedExpensesBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.CurrentAccruedExpensesBalanceSheet:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class CurrentAssetsBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The total amount of assets considered to be convertible into cash within a relatively short period of time, usually a year.
+    
+    CurrentAssetsBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.CurrentAssetsBalanceSheet:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class CurrentCapitalLeaseObligationBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Represents the total amount of long-term capital leases that must be paid within the next accounting PeriodAsByte. Capital lease
+                obligations are contractual obligations that arise from obtaining the use of property or equipment via a capital lease contract.
+    
+    CurrentCapitalLeaseObligationBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.CurrentCapitalLeaseObligationBalanceSheet:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class CurrentDebtAndCapitalLeaseObligationBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    All borrowings due within one year including current portions of long-term debt and capital leases as well as short-term debt such
+                as bank loans and commercial paper.
+    
+    CurrentDebtAndCapitalLeaseObligationBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.CurrentDebtAndCapitalLeaseObligationBalanceSheet:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class CurrentDebtBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Represents the total amount of long-term debt such as bank loans and commercial paper, which is due within one year.
+    
+    CurrentDebtBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.CurrentDebtBalanceSheet:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class CurrentDeferredAssetsBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Payments that will be assigned as expenses with one accounting period, but that are paid in advance and temporarily set up as
+                current assets on the balance sheet.
+    
+    CurrentDeferredAssetsBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.CurrentDeferredAssetsBalanceSheet:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class CurrentDeferredLiabilitiesBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Represents the current portion of obligations, which is a liability that usually would have been paid but is now past due.
+    
+    CurrentDeferredLiabilitiesBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.CurrentDeferredLiabilitiesBalanceSheet:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class CurrentDeferredRevenueBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Represents collections of cash or other assets related to revenue producing activity for which revenue has not yet been recognized.
+                Generally, an entity records deferred revenue when it receives consideration from a customer before achieving certain criteria that
+                must be met for revenue to be recognized in conformity with GAAP. It can be either current or non-current item. Also called
+                unearned revenue.
+    
+    CurrentDeferredRevenueBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.CurrentDeferredRevenueBalanceSheet:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class CurrentDeferredTaxesAssetsBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Meaning a future tax asset, resulting from temporary differences between book (accounting) value of assets and liabilities and their
+                tax value, or timing differences between the recognition of gains and losses in financial statements and their recognition in a tax
+                computation. It is also called future tax.
+    
+    CurrentDeferredTaxesAssetsBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.CurrentDeferredTaxesAssetsBalanceSheet:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class CurrentDeferredTaxesLiabilitiesBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Meaning a future tax liability, resulting from temporary differences between book (accounting) value of assets and liabilities and
+                their tax value, or timing differences between the recognition of gains and losses in financial statements and their recognition in a
+                tax computation. Deferred tax liabilities generally arise where tax relief is provided in advance of an accounting expense, or income
+                is accrued but not taxed until received.
+    
+    CurrentDeferredTaxesLiabilitiesBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.CurrentDeferredTaxesLiabilitiesBalanceSheet:
+        pass
+
+    NineMonths: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]

Algorithm.Python/stubs/QuantConnect/Data/__Fundamental_17.py

@@ -0,0 +1,342 @@
+from .__Fundamental_18 import *
+import typing
+import System.IO
+import System.Collections.Generic
+import System
+import QuantConnect.Data.Fundamental.MultiPeriodField
+import QuantConnect.Data.Fundamental
+import QuantConnect.Data
+import QuantConnect
+import datetime
+
+
+class CurrentLiabilitiesBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The debts or obligations of the firm that are due within one year.
+    
+    CurrentLiabilitiesBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.CurrentLiabilitiesBalanceSheet:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class CurrentNotesPayableBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Written promises to pay a stated sum at one or more specified dates in the future, within the accounting PeriodAsByte.
+    
+    CurrentNotesPayableBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.CurrentNotesPayableBalanceSheet:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class CurrentOtherFinancialLiabilitiesBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Other short term financial liabilities not categorized and due within one year or a normal operating cycle (whichever is longer).
+    
+    CurrentOtherFinancialLiabilitiesBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.CurrentOtherFinancialLiabilitiesBalanceSheet:
+        pass
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class CurrentProvisionsBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Provisions are created to protect the interests of one or both parties named in a contract or legal document which is a preparatory
+                action or measure. Current provision is expired within one accounting PeriodAsByte.
+    
+    CurrentProvisionsBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.CurrentProvisionsBalanceSheet:
+        pass
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class CurrentRatio(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Refers to the ratio of Current Assets to Current Liabilities. Morningstar calculates the ratio by using the underlying data reported in
+                the Balance Sheet within the company filings or reports:     Current Assets / Current Liabilities.
+    
+    CurrentRatio(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.CurrentRatio:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    OneYear: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class CurrentRatioGrowth(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The growth in the company's current ratio on a percentage basis. Morningstar calculates the growth percentage based on the
+                current assets divided by current liabilities reported in the Balance Sheet within the company filings or reports.
+    
+    CurrentRatioGrowth(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.CurrentRatioGrowth:
+        pass
+
+    FiveYears: float
+
+    OneYear: float
+
+    ThreeYears: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class CustomerAcceptancesBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Amounts receivable from customers on short-term negotiable time drafts drawn on and accepted by the institution (also known as
+                banker's acceptance transactions) that are outstanding on the reporting date.
+    
+    CustomerAcceptancesBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.CustomerAcceptancesBalanceSheet:
+        pass
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class CustomerAccountsBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Carrying value of amounts transferred by customers to third parties for security purposes that are expected to be returned or
+                applied towards payment after one year or beyond the operating cycle, if longer.
+    
+    CustomerAccountsBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.CustomerAccountsBalanceSheet:
+        pass
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class DaysInInventory(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    365 / Inventory turnover
+    
+    DaysInInventory(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.DaysInInventory:
+        pass
+
+    OneYear: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class DaysInPayment(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    365 / Payable turnover
+    
+    DaysInPayment(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.DaysInPayment:
+        pass
+
+    OneYear: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class DaysInSales(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    365 / Receivable Turnover
+    
+    DaysInSales(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.DaysInSales:
+        pass
+
+    OneYear: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class DDACostofRevenueIncomeStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Costs of depreciation and amortization on assets used for the revenue-generating activities during the accounting period
+    
+    DDACostofRevenueIncomeStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.DDACostofRevenueIncomeStatement:
+        pass
+
+    NineMonths: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class DebtDueBeyondBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Debt maturing beyond 5 years (eg. 5-10 years) or with no specified maturity, according to the debt maturity schedule reported by
+                the company.
+    
+    DebtDueBeyondBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.DebtDueBeyondBalanceSheet:
+        pass
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]

Algorithm.Python/stubs/QuantConnect/Data/__Fundamental_18.py

@@ -0,0 +1,340 @@
+from .__Fundamental_19 import *
+import typing
+import System.IO
+import System.Collections.Generic
+import System
+import QuantConnect.Data.Fundamental.MultiPeriodField
+import QuantConnect.Data.Fundamental
+import QuantConnect.Data
+import QuantConnect
+import datetime
+
+
+class DebtDueInYear1BalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Debt due under 1 year according to the debt maturity schedule reported by the company.
+    
+    DebtDueInYear1BalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.DebtDueInYear1BalanceSheet:
+        pass
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class DebtDueInYear2BalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Debt due under 2 years according to the debt maturity schedule reported by the company.
+    
+    DebtDueInYear2BalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.DebtDueInYear2BalanceSheet:
+        pass
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class DebtDueInYear5BalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Debt due within 5 year if the company provide maturity schedule in range e.g. 1-5 years, 2-5 years. Debt due under 5 years
+                according to the debt maturity schedule reported by the company. If a range is reported by the company, the value will be collected
+                under the maximum number of years (eg. 1-5 years, 3-5 years or 5 years will all be collected under this data point.)
+    
+    DebtDueInYear5BalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.DebtDueInYear5BalanceSheet:
+        pass
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class DebtSecuritiesBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Debt securities held as investments.
+    
+    DebtSecuritiesBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.DebtSecuritiesBalanceSheet:
+        pass
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class DebtSecuritiesinIssueBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Any debt financial instrument issued instead of cash loan.
+    
+    DebtSecuritiesinIssueBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.DebtSecuritiesinIssueBalanceSheet:
+        pass
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class DebttoAssets(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    This is a leverage ratio used to determine how much debt (a sum of long term and current portion of debt) a company has on its
+                balance sheet relative to total assets. This ratio examines the percent of the company that is financed by debt.
+    
+    DebttoAssets(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.DebttoAssets:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    OneYear: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class DebtTotalBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The total aggregate of all written promises and/or agreements to repay a stated amount of borrowed funds at a specified date in
+                the future; in a Non-Differentiated Balance Sheet.
+    
+    DebtTotalBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.DebtTotalBalanceSheet:
+        pass
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class DecreaseinInterestBearingDepositsinBankCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The net change on interest-bearing deposits in other financial institutions for relatively short periods of time including, for example,
+                certificates of deposits.
+    
+    DecreaseinInterestBearingDepositsinBankCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.DecreaseinInterestBearingDepositsinBankCashFlowStatement:
+        pass
+
+    NineMonths: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class DeferredAssetsBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    An amount owed to a firm that is not expected to be received by the firm within one year from the date of the balance sheet.
+    
+    DeferredAssetsBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.DeferredAssetsBalanceSheet:
+        pass
+
+    NineMonths: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class DeferredCostsBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    An expenditure not recognized as a cost of operation of the period in which incurred, but carried forward to be written off in future
+                periods.
+    
+    DeferredCostsBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.DeferredCostsBalanceSheet:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class DeferredIncomeTaxCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The component of income tax expense for the period representing the net change in the entities deferred tax assets and liabilities
+                pertaining to continuing operations.
+    
+    DeferredIncomeTaxCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.DeferredIncomeTaxCashFlowStatement:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class DeferredIncomeTotalBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Collections of cash or other assets related to revenue producing activity for which revenue has not yet been recognized on a Non-
+                Differentiated Balance Sheet.
+    
+    DeferredIncomeTotalBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.DeferredIncomeTotalBalanceSheet:
+        pass
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class DeferredPolicyAcquisitionCostsBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Net amount of deferred policy acquisition costs capitalized on contracts remaining in force as of the balance sheet date.
+    
+    DeferredPolicyAcquisitionCostsBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.DeferredPolicyAcquisitionCostsBalanceSheet:
+        pass
+
+    NineMonths: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]

Algorithm.Python/stubs/QuantConnect/Data/__Fundamental_19.py

@@ -0,0 +1,328 @@
+from .__Fundamental_20 import *
+import typing
+import System.IO
+import System.Collections.Generic
+import System
+import QuantConnect.Data.Fundamental.MultiPeriodField
+import QuantConnect.Data.Fundamental
+import QuantConnect.Data
+import QuantConnect
+import datetime
+
+
+class DeferredTaxAssetsBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    An asset on a company's balance sheet that may be used to reduce any subsequent period's income tax expense. Deferred tax
+                assets can arise due to net loss carryovers, which are only recorded as assets if it is deemed more likely than not that the asset
+                will be used in future fiscal periods.
+    
+    DeferredTaxAssetsBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.DeferredTaxAssetsBalanceSheet:
+        pass
+
+    NineMonths: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class DeferredTaxCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Future tax liability or asset, resulting from temporary differences between book (accounting) value of assets and liabilities, and their
+                tax value. This arises due to differences between financial accounting for shareholders and tax accounting.
+    
+    DeferredTaxCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.DeferredTaxCashFlowStatement:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class DeferredTaxLiabilitiesTotalBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    A future tax liability, resulting from temporary differences between book (accounting) value of assets and liabilities and their tax
+                value or timing differences between the recognition of gains and losses in financial statements, on a Non-Differentiated Balance
+                Sheet.
+    
+    DeferredTaxLiabilitiesTotalBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.DeferredTaxLiabilitiesTotalBalanceSheet:
+        pass
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class DefinedPensionBenefitBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The recognition of an asset where pension fund assets exceed promised benefits.
+    
+    DefinedPensionBenefitBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.DefinedPensionBenefitBalanceSheet:
+        pass
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class DepletionCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Unlike depreciation and amortization, which mainly describe the deduction of expenses due to the aging of equipment and property,
+                depletion is the actual physical reduction of natural resources by companies.   For example, coalmines, oil fields and other natural
+                resources are depleted on company accounting statements. This reduction in the quantity of resources is meant to assist in
+                accurately identifying the value of the asset on the balance sheet.
+    
+    DepletionCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.DepletionCashFlowStatement:
+        pass
+
+    NineMonths: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class DepletionIncomeStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The non-cash expense recognized on natural resources (eg. Oil and mineral deposits) over the benefit period of the asset.
+    
+    DepletionIncomeStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.DepletionIncomeStatement:
+        pass
+
+    NineMonths: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class DepositCertificatesBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    A savings certificate entitling the bearer to receive interest. A CD bears a maturity date, a specified fixed interest rate and can be
+                issued in any denomination.
+    
+    DepositCertificatesBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.DepositCertificatesBalanceSheet:
+        pass
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class DepositsbyBankBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Banks investment in the ongoing entity.
+    
+    DepositsbyBankBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.DepositsbyBankBalanceSheet:
+        pass
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class DepositsMadeunderAssumedReinsuranceContractBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Deposits made under reinsurance.
+    
+    DepositsMadeunderAssumedReinsuranceContractBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.DepositsMadeunderAssumedReinsuranceContractBalanceSheet:
+        pass
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class DepositsReceivedunderCededInsuranceContractBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Deposit received through ceded insurance contract.
+    
+    DepositsReceivedunderCededInsuranceContractBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.DepositsReceivedunderCededInsuranceContractBalanceSheet:
+        pass
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class DepreciationAmortizationDepletionCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    It is a non cash charge that represents a reduction in the value of fixed assets due to wear, age or obsolescence. This figure also
+                includes amortization of leased property, intangibles, and goodwill, and depletion. This non-cash item is an add-back to the cash
+                flow statement.
+    
+    DepreciationAmortizationDepletionCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.DepreciationAmortizationDepletionCashFlowStatement:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class DepreciationAmortizationDepletionIncomeStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The sum of depreciation, amortization and depletion expense in the Income Statement.
+                Depreciation is the non-cash expense recognized on tangible assets used in the normal course of business, by allocating the cost of
+                assets over their useful lives
+                Amortization is the non-cash expense recognized on intangible assets over the benefit period of the asset.
+                Depletion is the non-cash expense recognized on natural resources (eg. Oil and mineral deposits) over the benefit period of the
+                asset.
+    
+    DepreciationAmortizationDepletionIncomeStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.DepreciationAmortizationDepletionIncomeStatement:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]

Algorithm.Python/stubs/QuantConnect/Data/__Fundamental_2.py

@@ -0,0 +1,337 @@
+from .__Fundamental_3 import *
+import typing
+import System.IO
+import System.Collections.Generic
+import System
+import QuantConnect.Data.Fundamental.MultiPeriodField
+import QuantConnect.Data.Fundamental
+import QuantConnect.Data
+import QuantConnect
+import datetime
+
+
+class AmortizationOfSecuritiesCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Represents amortization of the allocation of a lump sum amount to different time periods, particularly for securities, debt, loans,
+                and other forms of financing. Does not include amortization, amortization of capital expenditure and intangible assets.
+    
+    AmortizationOfSecuritiesCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.AmortizationOfSecuritiesCashFlowStatement:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class AmortizationSupplementalIncomeStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The current period expense charged against earnings on intangible asset over its useful life. It is a supplemental value which would
+                be reported outside consolidated statements.
+    
+    AmortizationSupplementalIncomeStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.AmortizationSupplementalIncomeStatement:
+        pass
+
+    NineMonths: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class AssetClassification(System.object):
+    """
+    Definition of the AssetClassification class
+    
+    AssetClassification()
+    """
+    def UpdateValues(self, update: QuantConnect.Data.Fundamental.AssetClassification) -> None:
+        pass
+
+    CANNAICS: int
+
+    FinancialHealthGrade: str
+
+    GrowthGrade: str
+
+    GrowthScore: float
+
+    MorningstarEconomySphereCode: int
+
+    MorningstarIndustryCode: int
+
+    MorningstarIndustryGroupCode: int
+
+    MorningstarSectorCode: int
+
+    NACE: float
+
+    NAICS: int
+
+    ProfitabilityGrade: str
+
+    SIC: int
+
+    SizeScore: float
+
+    StockType: int
+
+    StyleBox: int
+
+    StyleScore: float
+
+    ValueScore: float
+
+
+
+class AssetImpairmentChargeCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The charge against earnings resulting from the aggregate write down of all assets from their carrying value to their fair value.
+    
+    AssetImpairmentChargeCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.AssetImpairmentChargeCashFlowStatement:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class AssetsHeldForSaleBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    This item is typically available for bank industry. It's a part of long-lived assets, which has been decided for sale in the future.
+    
+    AssetsHeldForSaleBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.AssetsHeldForSaleBalanceSheet:
+        pass
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class AssetsHeldForSaleCurrentBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Short term assets set apart for sale to liquidate in the future and are measured at the lower of carrying amount and fair value less
+                costs to sell.
+    
+    AssetsHeldForSaleCurrentBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.AssetsHeldForSaleCurrentBalanceSheet:
+        pass
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class AssetsHeldForSaleNonCurrentBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Long term assets set apart for sale to liquidate in the future and are measured at the lower of carrying amount and fair value less
+                costs to sell.
+    
+    AssetsHeldForSaleNonCurrentBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.AssetsHeldForSaleNonCurrentBalanceSheet:
+        pass
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class AssetsOfDiscontinuedOperationsBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    A portion of a company's business that has been disposed of or sold.
+    
+    AssetsOfDiscontinuedOperationsBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.AssetsOfDiscontinuedOperationsBalanceSheet:
+        pass
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class AssetsPledgedasCollateralSubjecttoSaleorRepledgingTotalBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Total value collateral assets pledged to the bank that can be sold or used as collateral for other loans.
+    
+    AssetsPledgedasCollateralSubjecttoSaleorRepledgingTotalBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.AssetsPledgedasCollateralSubjecttoSaleorRepledgingTotalBalanceSheet:
+        pass
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class AssetsTurnover(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Revenue / Average Total Assets
+    
+    AssetsTurnover(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.AssetsTurnover:
+        pass
+
+    OneYear: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class AvailableForSaleSecuritiesBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    For an unclassified balance sheet, this item represents equity securities categorized neither as held-to-maturity nor trading. Equity
+                securities represent ownership interests or the right to acquire ownership interests in corporations and other legal entities which
+                ownership interest is represented by shares of common or preferred stock (which is not mandatory redeemable or redeemable at
+                the option of the holder), convertible securities, stock rights, or stock warrants. This category includes preferred stocks, available-
+                for-sale and common stock, available-for-sale.
+    
+    AvailableForSaleSecuritiesBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.AvailableForSaleSecuritiesBalanceSheet:
+        pass
+
+    NineMonths: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class AverageDilutionEarningsIncomeStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Adjustments to reported net income to calculate Diluted EPS, by assuming that all convertible instruments are converted to
+                Common Equity. The adjustments usually include the interest expense of debentures when assumed converted and preferred
+                dividends of convertible preferred stock when assumed converted.
+    
+    AverageDilutionEarningsIncomeStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.AverageDilutionEarningsIncomeStatement:
+        pass
+
+    NineMonths: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]

Algorithm.Python/stubs/QuantConnect/Data/__Fundamental_20.py

@@ -0,0 +1,308 @@
+from .__Fundamental_21 import *
+import typing
+import System.IO
+import System.Collections.Generic
+import System
+import QuantConnect.Data.Fundamental.MultiPeriodField
+import QuantConnect.Data.Fundamental
+import QuantConnect.Data
+import QuantConnect
+import datetime
+
+
+class DepreciationAndAmortizationCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The current period expense charged against earnings on long-lived, physical assets used in the normal conduct of business and not
+                intended for resale to allocate or recognize the cost of assets over their useful lives; or to record the reduction in book value of an
+                intangible asset over the benefit period of such asset.
+    
+    DepreciationAndAmortizationCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.DepreciationAndAmortizationCashFlowStatement:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class DepreciationAndAmortizationIncomeStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The sum of depreciation and amortization expense in the Income Statement.
+                Depreciation is the non-cash expense recognized on tangible assets used in the normal course of business, by allocating the cost of
+                assets over their useful lives
+                Amortization is the non-cash expense recognized on intangible assets over the benefit period of the asset.
+    
+    DepreciationAndAmortizationIncomeStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.DepreciationAndAmortizationIncomeStatement:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class DepreciationCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    An expense recorded to allocate a tangible asset's cost over its useful life. Since it is a non-cash expense, it increases free cash
+                flow while decreasing reported earnings.
+    
+    DepreciationCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.DepreciationCashFlowStatement:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class DepreciationIncomeStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The current period non-cash expense recognized on tangible assets used in the normal course of business, by allocating the cost of
+                assets over their useful lives, in the Income Statement. Examples of tangible asset include buildings, production and equipment.
+    
+    DepreciationIncomeStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.DepreciationIncomeStatement:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class DepreciationSupplementalIncomeStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The current period expense charged against earnings on tangible asset over its useful life. It is a supplemental value which would
+                be reported outside consolidated statements.
+    
+    DepreciationSupplementalIncomeStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.DepreciationSupplementalIncomeStatement:
+        pass
+
+    NineMonths: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class DerivativeAssetsBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Fair values of assets resulting from contracts that meet the criteria of being accounted for as derivative instruments, net of the
+                effects of master netting arrangements.
+    
+    DerivativeAssetsBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.DerivativeAssetsBalanceSheet:
+        pass
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class DerivativeProductLiabilitiesBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Fair values of all liabilities resulting from contracts that meet the criteria of being accounted for as derivative instruments; and
+                which are expected to be extinguished or otherwise disposed of after one year or beyond the normal operating cycle.
+    
+    DerivativeProductLiabilitiesBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.DerivativeProductLiabilitiesBalanceSheet:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class DilutedAccountingChange(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Diluted EPS from Cumulative Effect Accounting Changes is the earnings from accounting changes (in the reporting period) divided
+                by the common shares outstanding adjusted for the assumed conversion of all potentially dilutive securities. Securities having a
+                dilutive effect may include convertible debentures, warrants, options, and convertible preferred stock.
+    
+    DilutedAccountingChange(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.DilutedAccountingChange:
+        pass
+
+    NineMonths: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class DilutedAverageShares(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The shares outstanding used to calculate the diluted EPS, assuming the conversion of all convertible securities and the exercise of
+                warrants or stock options. It is the weighted average diluted share outstanding through the whole accounting PeriodAsByte.  Note: If
+                Diluted Average Shares are not presented by the firm in the Income Statement and Basic Average Shares are presented, Diluted
+                Average Shares will equal Basic Average Shares.  However, if neither value is presented by the firm, Diluted Average Shares will be
+                null.
+    
+    DilutedAverageShares(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.DilutedAverageShares:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class DilutedContEPSGrowth(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The growth in the company's diluted EPS from continuing operations on a percentage basis. Morningstar calculates the annualized
+                growth percentage based on the underlying diluted EPS from continuing operations reported in the Income Statement within the
+                company filings or reports.
+    
+    DilutedContEPSGrowth(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.DilutedContEPSGrowth:
+        pass
+
+    FiveYears: float
+
+    OneYear: float
+
+    ThreeMonths: float
+
+    ThreeYears: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]

Algorithm.Python/stubs/QuantConnect/Data/__Fundamental_21.py

@@ -0,0 +1,329 @@
+from .__Fundamental_22 import *
+import typing
+import System.IO
+import System.Collections.Generic
+import System
+import QuantConnect.Data.Fundamental.MultiPeriodField
+import QuantConnect.Data.Fundamental
+import QuantConnect.Data
+import QuantConnect
+import datetime
+
+
+class DilutedContinuousOperations(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Diluted EPS from Continuing Operations is the earnings from continuing operations divided by the common shares outstanding
+                adjusted for the assumed conversion of all potentially dilutive securities.  Securities having a dilutive effect may include convertible
+                debentures, warrants, options, and convertible preferred stock.
+    
+    DilutedContinuousOperations(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.DilutedContinuousOperations:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class DilutedDiscontinuousOperations(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Diluted EPS from Discontinued Operations is the earnings from discontinued operations divided by the common shares outstanding
+                adjusted for the assumed conversion of all potentially dilutive securities. Securities having a dilutive effect may include convertible
+                debentures, warrants, options, and convertible preferred stock. This only includes gain or loss from discontinued operations.
+    
+    DilutedDiscontinuousOperations(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.DilutedDiscontinuousOperations:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class DilutedEPS(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Diluted EPS is the bottom line net income divided by the common shares outstanding adjusted for the assumed conversion of all
+                potentially dilutive securities. Securities having a dilutive effect may include convertible debentures, warrants, options, and
+                convertible preferred stock. This value will be derived when not reported for the fourth quarter and will be less than or equal to
+                Basic EPS.
+    
+    DilutedEPS(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.DilutedEPS:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class DilutedEPSGrowth(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The growth in the company's diluted earnings per share (EPS) on a percentage basis. Morningstar calculates the annualized growth
+                percentage based on the underlying diluted EPS reported in the Income Statement within the company filings or reports.
+    
+    DilutedEPSGrowth(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.DilutedEPSGrowth:
+        pass
+
+    FiveYears: float
+
+    OneYear: float
+
+    ThreeMonths: float
+
+    ThreeYears: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class DilutedEPSOtherGainsLosses(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The earnings from gains and losses (in the reporting period) divided by the common shares outstanding adjusted for the assumed
+                conversion of all potentially dilutive securities. Securities having a dilutive effect may include convertible debentures, warrants,
+                options, convertible preferred stock, etc.
+    
+    DilutedEPSOtherGainsLosses(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.DilutedEPSOtherGainsLosses:
+        pass
+
+    NineMonths: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class DilutedExtraordinary(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Diluted EPS from Extraordinary Gain/Losses is the gain or loss from extraordinary items divided by the common shares outstanding
+                adjusted for the assumed conversion of all potentially dilutive securities. Securities having a dilutive effect may include convertible
+                debentures, warrants, options, and convertible preferred stock.
+    
+    DilutedExtraordinary(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.DilutedExtraordinary:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class DilutedNIAvailtoComStockholdersIncomeStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Net income to calculate Diluted EPS, accounting for adjustments assuming that all the convertible instruments are being converted
+                to Common Equity.
+    
+    DilutedNIAvailtoComStockholdersIncomeStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.DilutedNIAvailtoComStockholdersIncomeStatement:
+        pass
+
+    NineMonths: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class DividendCoverageRatio(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Reflects a firm's capacity to pay a dividend, and is defined as Earnings Per Share / Dividend Per Share
+    
+    DividendCoverageRatio(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.DividendCoverageRatio:
+        pass
+
+    NineMonths: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class DividendIncomeIncomeStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Dividends earned from equity investment securities. This item is usually only available for bank industry.
+    
+    DividendIncomeIncomeStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.DividendIncomeIncomeStatement:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class DividendPaidCFOCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Dividend paid to the investors, in the Operating Cash Flow section.
+    
+    DividendPaidCFOCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.DividendPaidCFOCashFlowStatement:
+        pass
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class DividendPerShare(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The amount of dividend that a stockholder will receive for each share of stock held. It can be calculated by taking the total amount
+                of dividends paid and dividing it by the total shares outstanding. Dividend per share = total dividend payment/total number of
+                outstanding shares
+    
+    DividendPerShare(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.DividendPerShare:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]

Algorithm.Python/stubs/QuantConnect/Data/__Fundamental_22.py

@@ -0,0 +1,321 @@
+from .__Fundamental_23 import *
+import typing
+import System.IO
+import System.Collections.Generic
+import System
+import QuantConnect.Data.Fundamental.MultiPeriodField
+import QuantConnect.Data.Fundamental
+import QuantConnect.Data
+import QuantConnect
+import datetime
+
+
+class DividendReceivedCFOCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Dividend received on investment, in the Operating Cash Flow section.
+    
+    DividendReceivedCFOCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.DividendReceivedCFOCashFlowStatement:
+        pass
+
+    SixMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class DividendsPaidDirectCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Dividend paid to the investors, for the direct cash flow.
+    
+    DividendsPaidDirectCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.DividendsPaidDirectCashFlowStatement:
+        pass
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class DividendsPayableBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Sum of the carrying values of dividends declared but unpaid on equity securities issued and outstanding (also includes dividends
+                collected on behalf of another owner of securities that are being held by entity) by the entity.
+    
+    DividendsPayableBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.DividendsPayableBalanceSheet:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class DividendsReceivedCFICashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Dividend received on investment, in the Investing Cash Flow section.
+    
+    DividendsReceivedCFICashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.DividendsReceivedCFICashFlowStatement:
+        pass
+
+    NineMonths: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class DividendsReceivedDirectCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Dividend received on the investment, for the direct cash flow.
+    
+    DividendsReceivedDirectCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.DividendsReceivedDirectCashFlowStatement:
+        pass
+
+    NineMonths: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class DPSGrowth(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The growth in the company's dividends per share (DPS) on a percentage basis. Morningstar calculates the annualized growth
+                percentage based on the underlying DPS from its dividend database.  Morningstar collects its DPS from company filings and
+                reports, as well as from third party sources.
+    
+    DPSGrowth(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.DPSGrowth:
+        pass
+
+    FiveYears: float
+
+    OneYear: float
+
+    ThreeMonths: float
+
+    ThreeYears: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class DueFromRelatedPartiesBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    For an unclassified balance sheet, carrying amount as of the balance sheet date of obligations due all related parties.
+    
+    DueFromRelatedPartiesBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.DueFromRelatedPartiesBalanceSheet:
+        pass
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class DuefromRelatedPartiesCurrentBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Amounts owed to the company from a non-arm's length entity, due within the company's current operating cycle.
+    
+    DuefromRelatedPartiesCurrentBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.DuefromRelatedPartiesCurrentBalanceSheet:
+        pass
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class DuefromRelatedPartiesNonCurrentBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Amounts owed to the company from a non-arm's length entity, due after the company's current operating cycle.
+    
+    DuefromRelatedPartiesNonCurrentBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.DuefromRelatedPartiesNonCurrentBalanceSheet:
+        pass
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class DuetoRelatedPartiesBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Amounts owed by the company to a non-arm's length entity.
+    
+    DuetoRelatedPartiesBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.DuetoRelatedPartiesBalanceSheet:
+        pass
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class DuetoRelatedPartiesCurrentBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Amounts owed by the company to a non-arm's length entity that has to be repaid within the company's current operating cycle.
+    
+    DuetoRelatedPartiesCurrentBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.DuetoRelatedPartiesCurrentBalanceSheet:
+        pass
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class DuetoRelatedPartiesNonCurrentBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Amounts owed by the company to a non-arm's length entity that has to be repaid after the company's current operating cycle.
+    
+    DuetoRelatedPartiesNonCurrentBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.DuetoRelatedPartiesNonCurrentBalanceSheet:
+        pass
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class EarningRatios(System.object):
+    """
+    Definition of the EarningRatios class
+    
+    EarningRatios()
+    """
+    def UpdateValues(self, update: QuantConnect.Data.Fundamental.EarningRatios) -> None:
+        pass
+
+    BookValuePerShareGrowth: QuantConnect.Data.Fundamental.BookValuePerShareGrowth
+
+    DilutedContEPSGrowth: QuantConnect.Data.Fundamental.DilutedContEPSGrowth
+
+    DilutedEPSGrowth: QuantConnect.Data.Fundamental.DilutedEPSGrowth
+
+    DPSGrowth: QuantConnect.Data.Fundamental.DPSGrowth
+
+    EquityPerShareGrowth: QuantConnect.Data.Fundamental.EquityPerShareGrowth
+
+    FCFPerShareGrowth: QuantConnect.Data.Fundamental.FCFPerShareGrowth
+
+    NormalizedBasicEPSGrowth: QuantConnect.Data.Fundamental.NormalizedBasicEPSGrowth
+
+    NormalizedDilutedEPSGrowth: QuantConnect.Data.Fundamental.NormalizedDilutedEPSGrowth
+
+    RegressionGrowthofDividends5Years: QuantConnect.Data.Fundamental.RegressionGrowthofDividends5Years

Algorithm.Python/stubs/QuantConnect/Data/__Fundamental_23.py

@@ -0,0 +1,350 @@
+from .__Fundamental_24 import *
+import typing
+import System.IO
+import System.Collections.Generic
+import System
+import QuantConnect.Data.Fundamental.MultiPeriodField
+import QuantConnect.Data.Fundamental
+import QuantConnect.Data
+import QuantConnect
+import datetime
+
+
+
+class EarningReports(System.object):
+    """
+    Definition of the EarningReports class
+    
+    EarningReports()
+    """
+    def UpdateValues(self, update: QuantConnect.Data.Fundamental.EarningReports) -> None:
+        pass
+
+    AccessionNumber: str
+
+    BasicAccountingChange: QuantConnect.Data.Fundamental.BasicAccountingChange
+
+    BasicAverageShares: QuantConnect.Data.Fundamental.BasicAverageShares
+
+    BasicContinuousOperations: QuantConnect.Data.Fundamental.BasicContinuousOperations
+
+    BasicDiscontinuousOperations: QuantConnect.Data.Fundamental.BasicDiscontinuousOperations
+
+    BasicEPS: QuantConnect.Data.Fundamental.BasicEPS
+
+    BasicEPSOtherGainsLosses: QuantConnect.Data.Fundamental.BasicEPSOtherGainsLosses
+
+    BasicExtraordinary: QuantConnect.Data.Fundamental.BasicExtraordinary
+
+    ContinuingAndDiscontinuedBasicEPS: QuantConnect.Data.Fundamental.ContinuingAndDiscontinuedBasicEPS
+
+    ContinuingAndDiscontinuedDilutedEPS: QuantConnect.Data.Fundamental.ContinuingAndDiscontinuedDilutedEPS
+
+    DilutedAccountingChange: QuantConnect.Data.Fundamental.DilutedAccountingChange
+
+    DilutedAverageShares: QuantConnect.Data.Fundamental.DilutedAverageShares
+
+    DilutedContinuousOperations: QuantConnect.Data.Fundamental.DilutedContinuousOperations
+
+    DilutedDiscontinuousOperations: QuantConnect.Data.Fundamental.DilutedDiscontinuousOperations
+
+    DilutedEPS: QuantConnect.Data.Fundamental.DilutedEPS
+
+    DilutedEPSOtherGainsLosses: QuantConnect.Data.Fundamental.DilutedEPSOtherGainsLosses
+
+    DilutedExtraordinary: QuantConnect.Data.Fundamental.DilutedExtraordinary
+
+    DividendCoverageRatio: QuantConnect.Data.Fundamental.DividendCoverageRatio
+
+    DividendPerShare: QuantConnect.Data.Fundamental.DividendPerShare
+
+    FileDate: datetime.datetime
+
+    FormType: str
+
+    NormalizedBasicEPS: QuantConnect.Data.Fundamental.NormalizedBasicEPS
+
+    NormalizedDilutedEPS: QuantConnect.Data.Fundamental.NormalizedDilutedEPS
+
+    PeriodEndingDate: datetime.datetime
+
+    PeriodType: str
+
+    ReportedNormalizedBasicEPS: QuantConnect.Data.Fundamental.ReportedNormalizedBasicEPS
+
+    ReportedNormalizedDilutedEPS: QuantConnect.Data.Fundamental.ReportedNormalizedDilutedEPS
+
+    TaxLossCarryforwardBasicEPS: QuantConnect.Data.Fundamental.TaxLossCarryforwardBasicEPS
+
+    TaxLossCarryforwardDilutedEPS: QuantConnect.Data.Fundamental.TaxLossCarryforwardDilutedEPS
+
+    TotalDividendPerShare: QuantConnect.Data.Fundamental.TotalDividendPerShare
+
+
+
+class EarningsFromEquityInterestIncomeStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The earnings from equity interest can be a result of any of the following: Income from earnings distribution of the business, either
+                as dividends paid to corporate shareholders or as drawings in a partnership; Capital gain realized upon sale of the business; Capital
+                gain realized from selling his or her interest to other partners. This item is usually not available for bank and insurance industries.
+    
+    EarningsFromEquityInterestIncomeStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.EarningsFromEquityInterestIncomeStatement:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class EarningsfromEquityInterestNetOfTaxIncomeStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Income from other equity interest reported after Provision of Tax. This applies to all industries.
+    
+    EarningsfromEquityInterestNetOfTaxIncomeStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.EarningsfromEquityInterestNetOfTaxIncomeStatement:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class EarningsLossesFromEquityInvestmentsCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    This item represents the entity's proportionate share for the period of the net income (loss) of its investee (such as unconsolidated
+                subsidiaries and joint ventures) to which the equity method of accounting is applied. The amount typically reflects adjustments.
+    
+    EarningsLossesFromEquityInvestmentsCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.EarningsLossesFromEquityInvestmentsCashFlowStatement:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class EBITDAGrowth(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The growth in the company's EBITDA on a percentage basis. Morningstar calculates the growth percentage based on the earnings
+                minus expenses (excluding interest, tax, depreciation, and amortization expenses) reported in the Financial Statements within the
+                company filings or reports.
+    
+    EBITDAGrowth(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.EBITDAGrowth:
+        pass
+
+    FiveYears: float
+
+    OneYear: float
+
+    ThreeYears: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class EBITDAIncomeStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Earnings minus expenses (excluding interest, tax, depreciation, and amortization expenses).
+    
+    EBITDAIncomeStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.EBITDAIncomeStatement:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class EBITDAMargin(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Refers to the ratio of earnings before interest, taxes and depreciation and amortization to revenue. Morningstar calculates the ratio
+                by using the underlying data reported in the company filings or reports:   EBITDA / Revenue.
+    
+    EBITDAMargin(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.EBITDAMargin:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    OneYear: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class EBITIncomeStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Earnings minus expenses (excluding interest and tax expenses).
+    
+    EBITIncomeStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.EBITIncomeStatement:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class EBITMargin(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Refers to the ratio of earnings before interest and taxes to revenue. Morningstar calculates the ratio by using the underlying data
+                reported in the company filings or reports:   EBIT / Revenue.
+    
+    EBITMargin(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.EBITMargin:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    OneYear: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class EffectiveTaxRateAsReportedIncomeStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The average tax rate for the period as reported by the company, may be the same or not the same as Morningstar's standardized
+                definition.
+    
+    EffectiveTaxRateAsReportedIncomeStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.EffectiveTaxRateAsReportedIncomeStatement:
+        pass
+
+    NineMonths: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]

Algorithm.Python/stubs/QuantConnect/Data/__Fundamental_24.py

@@ -0,0 +1,325 @@
+from .__Fundamental_25 import *
+import typing
+import System.IO
+import System.Collections.Generic
+import System
+import QuantConnect.Data.Fundamental.MultiPeriodField
+import QuantConnect.Data.Fundamental
+import QuantConnect.Data
+import QuantConnect
+import datetime
+
+
+class EffectOfExchangeRateChangesCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The effect of exchange rate changes on cash balances held in foreign currencies.
+    
+    EffectOfExchangeRateChangesCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.EffectOfExchangeRateChangesCashFlowStatement:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class ElectricUtilityPlantBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The amount for the electric plant related to the utility industry.
+    
+    ElectricUtilityPlantBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.ElectricUtilityPlantBalanceSheet:
+        pass
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class EmployeeBenefitsBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Carrying amount as of the balance sheet date of the portion of the obligations recognized for the various benefits provided to former
+                or inactive employees, their beneficiaries, and covered dependents after employment but before retirement.
+    
+    EmployeeBenefitsBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.EmployeeBenefitsBalanceSheet:
+        pass
+
+    NineMonths: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class EndCashPositionCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The cash and cash equivalents balance at the end of the accounting period, as indicated on the Cash Flow statement. It is equal to
+                the Beginning Cash and Equivalents, plus the Net Change in Cash and Equivalents.
+    
+    EndCashPositionCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.EndCashPositionCashFlowStatement:
+        pass
+
+    NineMonths: float
+
+    OneMonth: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class EquipmentIncomeStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Equipment expenses include depreciation, repairs, rentals, and service contract costs. This also includes equipment purchases
+                which do not qualify for capitalization in accordance with the entity's accounting policy. This item may also include furniture
+                expenses. This item is usually only available for bank industry.
+    
+    EquipmentIncomeStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.EquipmentIncomeStatement:
+        pass
+
+    NineMonths: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class EquityAttributableToOwnersOfParentBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """ EquityAttributableToOwnersOfParentBalanceSheet(store: IDictionary[str, Decimal]) """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.EquityAttributableToOwnersOfParentBalanceSheet:
+        pass
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class EquityInvestmentsBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    This asset represents equity securities categorized neither as held-to-maturity nor trading.
+    
+    EquityInvestmentsBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.EquityInvestmentsBalanceSheet:
+        pass
+
+    NineMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class EquityPerShareGrowth(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    The growth in the company's book value per share on a percentage basis. Morningstar calculates the annualized growth
+                percentage based on the underlying equity and end of period shares outstanding reported in the company filings or reports.
+    
+    EquityPerShareGrowth(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.EquityPerShareGrowth:
+        pass
+
+    FiveYears: float
+
+    OneYear: float
+
+    ThreeMonths: float
+
+    ThreeYears: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class EquitySharesInvestmentsBalanceSheet(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Investments in shares of a company representing ownership in that company.
+    
+    EquitySharesInvestmentsBalanceSheet(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.EquitySharesInvestmentsBalanceSheet:
+        pass
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class ExcessTaxBenefitFromStockBasedCompensationCashFlowStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Reductions in the entity's income taxes that arise when compensation cost (from non-qualified share-based compensation)
+                recognized on the entities tax return exceeds compensation cost from share-based compensation recognized in financial
+                statements. This element reduces net cash provided by operating activities.
+    
+    ExcessTaxBenefitFromStockBasedCompensationCashFlowStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.ExcessTaxBenefitFromStockBasedCompensationCashFlowStatement:
+        pass
+
+    NineMonths: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    TwoMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class ExciseTaxesIncomeStatement(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    Excise taxes are taxes paid when purchases are made on a specific good, such as gasoline. Excise taxes are often included in the
+                price of the product. There are also excise taxes on activities, such as on wagering or on highway usage by trucks.
+    
+    ExciseTaxesIncomeStatement(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.ExciseTaxesIncomeStatement:
+        pass
+
+    NineMonths: float
+
+    SixMonths: float
+
+    ThreeMonths: float
+
+    TwelveMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]
+
+
+class ExpenseRatio(QuantConnect.Data.Fundamental.MultiPeriodField):
+    """
+    A measure of operating performance for Insurance companies, as it shows the relationship between the premiums earned and
+                administrative expenses related to claims such as fees and commissions. A number of 1 or lower is preferred, as this means the
+                premiums exceed the expenses. Calculated as: (Deferred Policy Acquisition Amortization Expense+Fees and Commission
+                Expense+Other Underwriting Expenses+Selling, General and Administrative) / Net Premiums Earned
+    
+    ExpenseRatio(store: IDictionary[str, Decimal])
+    """
+    def GetPeriodValue(self, period: str) -> float:
+        pass
+
+    def SetPeriodValue(self, period: str, value: float) -> None:
+        pass
+
+    def __init__(self, store: System.Collections.Generic.IDictionary[str, float]) -> QuantConnect.Data.Fundamental.ExpenseRatio:
+        pass
+
+    OneYear: float
+
+    ThreeMonths: float
+
+    Store: typing.List[QuantConnect.Data.Fundamental.MultiPeriodField.PeriodField]