Remove LUNG from blacklisted tickers (#4966)

* Support Bitfinex live settings

* Add Alpaca and GDAX and their respective tests

* Address review

.gitignore

@@ -271,3 +271,6 @@ QuantConnect.Lean.sln.DotSettings*
 
 #User notebook files
 Research/Notebooks
+
+#Docker result files
+Results/

.idea/Lean.iml

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

.idea/readme.md

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

.travis.yml

@@ -23,4 +23,4 @@ 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
+  - sudo -E ./ci_build_stubs.sh -d -t -g -p

.vs/readme.md

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

.vscode/readme.md

@@ -101,14 +101,14 @@ This section will cover how to actually launch Lean in the container with your d
 
 <h3>Option 1 (Recommended)</h3>
 
-In VS Code click on the debug/run icon on the left toolbar, at the top you should see a drop down menu with launch options, be sure to select **Debug in Container**. This option will kick off a launch script that will start the docker. With this specific launch option the parameters are already configured in VS Codes **tasks.json** under the **run-docker** task args. These set arguements are:
+In VS Code click on the debug/run icon on the left toolbar, at the top you should see a drop down menu with launch options, be sure to select **Debug in Container**. This option will kick off a launch script that will start the docker. With this specific launch option the parameters are already configured in VS Codes **tasks.json** under the **run-docker** task args. These set arguments are:
 
-    "image=quantconnect/lean:latest",
-    "config_file=${workspaceFolder}/Launcher/config.json",
-    "data_dir=${workspaceFolder}/Data",
-    "results_dir=${workspaceFolder}/",
-    "debugging=Y",
-    "python_location=${workspaceFolder}/Algorithm.Python"
+    "IMAGE=quantconnect/lean:latest",
+    "CONFIG_FILE=${workspaceFolder}/Launcher/config.json",
+    "DATA_DIR=${workspaceFolder}/Data",
+    "RESULTS_DIR=${workspaceFolder}/Results",
+    "DEBUGGING=Y",
+    "PYHTON_DIR=${workspaceFolder}/Algorithm.Python"
 
 As defaults these are all great! Feel free to change them as needed for your setup.
 
@@ -120,21 +120,21 @@ From a terminal launch the run_docker.bat/.sh script; there are a few choices on
  1. Launch with no parameters and answer the questions regarding configuration (Press enter for defaults)
    
         *   Enter docker image [default: quantconnect/lean:latest]:
-        *   Enter absolute path to Lean config file [default: _~currentDir_\Launcher\config.json]:
-        *   Enter absolute path to Data folder [default: ~_currentDir_\Data\]:
-        *   Enter absolute path to store results [default: ~_currentDir_\]:
+        *   Enter absolute path to Lean config file [default: .\Launcher\config.json]:
+        *   Enter absolute path to Data folder [default: .\Data\]:
+        *   Enter absolute path to store results [default: .\Results]:
         *   Would you like to debug C#? (Requires mono debugger attachment) [default: N]:
 
  2. Using the **run_docker.cfg** to store args for repeated use; any blank entries will resort to default values! example: **_./run_docker.bat run_docker.cfg_**
   
-        image=quantconnect/lean:latest
-        config_file=
-        data_dir=
-        results_dir=
-        debugging=
-        python_dir=
+        IMAGE=quantconnect/lean:latest
+        CONFIG_FILE=
+        DATA_DIR=
+        RESULTS_DIR=
+        DEBUGGING=
+        PYTHON_DIR=
 
- 3. Inline arguments; anything you don't enter will use the default args! example: **_./run_docker.bat debugging=y_** 
+ 3. Inline arguments; anything you don't enter will use the default args! example: **_./run_docker.bat DEBUGGING=y_** 
       *    Accepted args for inline include all listed in the file in #2
 
 <br />

.vscode/settings.json

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

.vscode/tasks.json

@@ -51,13 +51,13 @@
                 "command": "${workspaceFolder}/run_docker.sh"
             },
             "args": [
-                "image=quantconnect/lean:latest",
-                "config_file=${workspaceFolder}/Launcher/config.json",
-                "data_dir=${workspaceFolder}/Data",
-                "results_dir=${workspaceFolder}/",
-                "debugging=Y",
-                "python_dir=${workspaceFolder}/Algorithm.Python",
-                "exit=Y"
+                "IMAGE=quantconnect/lean:latest",
+                "CONFIG_FILE=${workspaceFolder}/Launcher/config.json",
+                "DATA_DIR=${workspaceFolder}/Data",
+                "RESULTS_DIR=${workspaceFolder}/Results",
+                "DEBUGGING=Y",
+                "PYTHON_DIR=${workspaceFolder}/Algorithm.Python",
+                "EXIT=Y"
             ],
             "problemMatcher": [
                 {

Algorithm.CSharp/AddOptionContractExpiresRegressionAlgorithm.cs

@@ -0,0 +1,164 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
+using System;
+using System.Linq;
+using QuantConnect.Data;
+using QuantConnect.Interfaces;
+using System.Collections.Generic;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// We add an option contract using <see cref="QCAlgorithm.AddOptionContract"/> and place a trade and wait till it expires
+    /// later will liquidate the resulting equity position and assert both option and underlying get removed
+    /// </summary>
+    public class AddOptionContractExpiresRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private DateTime _expiration = new DateTime(2014, 06, 21);
+        private Symbol _option;
+        private Symbol _twx;
+        private bool _traded;
+
+        public override void Initialize()
+        {
+            SetStartDate(2014, 06, 05);
+            SetEndDate(2014, 06, 30);
+
+            _twx = QuantConnect.Symbol.Create("TWX", SecurityType.Equity, Market.USA);
+
+            AddUniverse("my-daily-universe-name", time => new List<string> { "AAPL" });
+        }
+
+        public override void OnData(Slice data)
+        {
+            if (_option == null)
+            {
+                var option = OptionChainProvider.GetOptionContractList(_twx, Time)
+                    .OrderBy(symbol => symbol.ID.Symbol)
+                    .FirstOrDefault(optionContract => optionContract.ID.Date == _expiration
+                                                      && optionContract.ID.OptionRight == OptionRight.Call
+                                                      && optionContract.ID.OptionStyle == OptionStyle.American);
+                if (option != null)
+                {
+                    _option = AddOptionContract(option).Symbol;
+                }
+            }
+
+            if (_option != null && Securities[_option].Price != 0 && !_traded)
+            {
+                _traded = true;
+                Buy(_option, 1);
+
+                foreach (var symbol in new [] { _option, _option.Underlying })
+                {
+                    var config = SubscriptionManager.SubscriptionDataConfigService.GetSubscriptionDataConfigs(symbol).ToList();
+
+                    if (!config.Any())
+                    {
+                        throw new Exception($"Was expecting configurations for {symbol}");
+                    }
+                    if (config.Any(dataConfig => dataConfig.DataNormalizationMode != DataNormalizationMode.Raw))
+                    {
+                        throw new Exception($"Was expecting DataNormalizationMode.Raw configurations for {symbol}");
+                    }
+                }
+            }
+
+            if (Time.Date > _expiration)
+            {
+                if (SubscriptionManager.SubscriptionDataConfigService.GetSubscriptionDataConfigs(_option).Any())
+                {
+                    throw new Exception($"Unexpected configurations for {_option} after it has been delisted");
+                }
+
+                if (Securities[_twx].Invested)
+                {
+                    if (!SubscriptionManager.SubscriptionDataConfigService.GetSubscriptionDataConfigs(_twx).Any())
+                    {
+                        throw new Exception($"Was expecting configurations for {_twx}");
+                    }
+
+                    // first we liquidate the option exercised position
+                    Liquidate(_twx);
+                }
+            }
+            else if (Time.Date > _expiration && !Securities[_twx].Invested)
+            {
+                if (SubscriptionManager.SubscriptionDataConfigService.GetSubscriptionDataConfigs(_twx).Any())
+                {
+                    throw new Exception($"Unexpected configurations for {_twx} after it has been liquidated");
+                }
+            }
+        }
+
+        /// <summary>
+        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
+        /// </summary>
+        public bool CanRunLocally { get; } = true;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public Language[] Languages { get; } = { Language.CSharp, Language.Python };
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        {
+            {"Total Trades", "3"},
+            {"Average Win", "2.73%"},
+            {"Average Loss", "-2.98%"},
+            {"Compounding Annual Return", "-4.619%"},
+            {"Drawdown", "0.300%"},
+            {"Expectancy", "-0.042"},
+            {"Net Profit", "-0.332%"},
+            {"Sharpe Ratio", "-3.7"},
+            {"Probabilistic Sharpe Ratio", "0.563%"},
+            {"Loss Rate", "50%"},
+            {"Win Rate", "50%"},
+            {"Profit-Loss Ratio", "0.92"},
+            {"Alpha", "-0.023"},
+            {"Beta", "0.005"},
+            {"Annual Standard Deviation", "0.006"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "-3.424"},
+            {"Tracking Error", "0.057"},
+            {"Treynor Ratio", "-4.775"},
+            {"Total Fees", "$2.00"},
+            {"Fitness Score", "0"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "-43.418"},
+            {"Return Over Maximum Drawdown", "-14.274"},
+            {"Portfolio Turnover", "0.007"},
+            {"Total Insights Generated", "0"},
+            {"Total Insights Closed", "0"},
+            {"Total Insights Analysis Completed", "0"},
+            {"Long Insight Count", "0"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "$0"},
+            {"Total Accumulated Estimated Alpha Value", "$0"},
+            {"Mean Population Estimated Insight Value", "$0"},
+            {"Mean Population Direction", "0%"},
+            {"Mean Population Magnitude", "0%"},
+            {"Rolling Averaged Population Direction", "0%"},
+            {"Rolling Averaged Population Magnitude", "0%"},
+            {"OrderListHash", "-1185639451"}
+        };
+    }
+}

Algorithm.CSharp/AddOptionContractFromUniverseRegressionAlgorithm.cs

@@ -0,0 +1,216 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using QuantConnect.Data;
+using QuantConnect.Data.UniverseSelection;
+using QuantConnect.Interfaces;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// We add an option contract using <see cref="QCAlgorithm.AddOptionContract"/> and place a trade, the underlying
+    /// gets deselected from the universe selection but should still be present since we manually added the option contract.
+    /// Later we call <see cref="QCAlgorithm.RemoveOptionContract"/> and expect both option and underlying to be removed.
+    /// </summary>
+    public class AddOptionContractFromUniverseRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private DateTime _expiration = new DateTime(2014, 06, 21);
+        private SecurityChanges _securityChanges = SecurityChanges.None;
+        private Symbol _option;
+        private Symbol _aapl;
+        private Symbol _twx;
+        private bool _traded;
+
+        public override void Initialize()
+        {
+            _twx = QuantConnect.Symbol.Create("TWX", SecurityType.Equity, Market.USA);
+            _aapl = QuantConnect.Symbol.Create("AAPL", SecurityType.Equity, Market.USA);
+            UniverseSettings.Resolution = Resolution.Minute;
+            UniverseSettings.DataNormalizationMode = DataNormalizationMode.Raw;
+
+            SetStartDate(2014, 06, 05);
+            SetEndDate(2014, 06, 09);
+
+            AddUniverse(enumerable => new[] { Time.Date <= new DateTime(2014, 6, 5) ? _twx : _aapl },
+                enumerable => new[] { Time.Date <= new DateTime(2014, 6, 5) ? _twx : _aapl });
+        }
+
+        public override void OnData(Slice data)
+        {
+            if (_option != null && Securities[_option].Price != 0 && !_traded)
+            {
+                _traded = true;
+                Buy(_option, 1);
+            }
+
+            if (Time.Date > new DateTime(2014, 6, 5))
+            {
+                if (Time < new DateTime(2014, 6, 6, 14, 0, 0))
+                {
+                    var configs = SubscriptionManager.SubscriptionDataConfigService.GetSubscriptionDataConfigs(_twx);
+                    // assert underlying still there after the universe selection removed it, still used by the manually added option contract
+                    if (!configs.Any())
+                    {
+                        throw new Exception($"Was expecting configurations for {_twx}" +
+                                            $" even after it has been deselected from coarse universe because we still have the option contract.");
+                    }
+                }
+                else if (Time == new DateTime(2014, 6, 6, 14, 0, 0))
+                {
+                    // liquidate & remove the option
+                    RemoveOptionContract(_option);
+                }
+                // assert underlying was finally removed
+                else if(Time > new DateTime(2014, 6, 6, 14, 0, 0))
+                {
+                    foreach (var symbol in new[] { _option, _option.Underlying })
+                    {
+                        var configs = SubscriptionManager.SubscriptionDataConfigService.GetSubscriptionDataConfigs(symbol);
+                        if (configs.Any())
+                        {
+                            throw new Exception($"Unexpected configuration for {symbol} after it has been deselected from coarse universe and option contract is removed.");
+                        }
+                    }
+                }
+            }
+        }
+
+        public override void OnSecuritiesChanged(SecurityChanges changes)
+        {
+            if (_securityChanges.RemovedSecurities.Intersect(changes.RemovedSecurities).Any())
+            {
+                throw new Exception($"SecurityChanges.RemovedSecurities intersect {changes.RemovedSecurities}. We expect no duplicate!");
+            }
+            if (_securityChanges.AddedSecurities.Intersect(changes.AddedSecurities).Any())
+            {
+                throw new Exception($"SecurityChanges.AddedSecurities intersect {changes.RemovedSecurities}. We expect no duplicate!");
+            }
+            // keep track of all removed and added securities
+            _securityChanges += changes;
+
+            if (changes.AddedSecurities.Any(security => security.Symbol.SecurityType == SecurityType.Option))
+            {
+                return;
+            }
+
+            foreach (var addedSecurity in changes.AddedSecurities)
+            {
+                var option = OptionChainProvider.GetOptionContractList(addedSecurity.Symbol, Time)
+                    .OrderBy(symbol => symbol.ID.Symbol)
+                    .First(optionContract => optionContract.ID.Date == _expiration
+                                                      && optionContract.ID.OptionRight == OptionRight.Call
+                                                      && optionContract.ID.OptionStyle == OptionStyle.American);
+                AddOptionContract(option);
+
+                foreach (var symbol in new[] { option, option.Underlying })
+                {
+                    var config = SubscriptionManager.SubscriptionDataConfigService.GetSubscriptionDataConfigs(symbol).ToList();
+
+                    if (!config.Any())
+                    {
+                        throw new Exception($"Was expecting configurations for {symbol}");
+                    }
+                    if (config.Any(dataConfig => dataConfig.DataNormalizationMode != DataNormalizationMode.Raw))
+                    {
+                        throw new Exception($"Was expecting DataNormalizationMode.Raw configurations for {symbol}");
+                    }
+                }
+
+                // just keep the first we got
+                if (_option == null)
+                {
+                    _option = option;
+                }
+            }
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            if (SubscriptionManager.Subscriptions.Any(dataConfig => dataConfig.Symbol == _twx || dataConfig.Symbol.Underlying == _twx))
+            {
+                throw new Exception($"Was NOT expecting any configurations for {_twx} or it's options, since we removed the contract");
+            }
+
+            if (SubscriptionManager.Subscriptions.All(dataConfig => dataConfig.Symbol != _aapl))
+            {
+                throw new Exception($"Was expecting configurations for {_aapl}");
+            }
+            if (SubscriptionManager.Subscriptions.All(dataConfig => dataConfig.Symbol.Underlying != _aapl))
+            {
+                throw new Exception($"Was expecting options configurations for {_aapl}");
+            }
+        }
+
+        /// <summary>
+        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
+        /// </summary>
+        public bool CanRunLocally { get; } = true;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public Language[] Languages { get; } = { Language.CSharp, Language.Python };
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        {
+            {"Total Trades", "2"},
+            {"Average Win", "0%"},
+            {"Average Loss", "-0.23%"},
+            {"Compounding Annual Return", "-15.596%"},
+            {"Drawdown", "0.200%"},
+            {"Expectancy", "-1"},
+            {"Net Profit", "-0.232%"},
+            {"Sharpe Ratio", "-7.739"},
+            {"Probabilistic Sharpe Ratio", "1.216%"},
+            {"Loss Rate", "100%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "0.027"},
+            {"Beta", "-0.174"},
+            {"Annual Standard Deviation", "0.006"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "-11.586"},
+            {"Tracking Error", "0.042"},
+            {"Treynor Ratio", "0.286"},
+            {"Total Fees", "$2.00"},
+            {"Fitness Score", "0"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "-19.883"},
+            {"Return Over Maximum Drawdown", "-67.224"},
+            {"Portfolio Turnover", "0.014"},
+            {"Total Insights Generated", "0"},
+            {"Total Insights Closed", "0"},
+            {"Total Insights Analysis Completed", "0"},
+            {"Long Insight Count", "0"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "$0"},
+            {"Total Accumulated Estimated Alpha Value", "$0"},
+            {"Mean Population Estimated Insight Value", "$0"},
+            {"Mean Population Direction", "0%"},
+            {"Mean Population Magnitude", "0%"},
+            {"Rolling Averaged Population Direction", "0%"},
+            {"Rolling Averaged Population Magnitude", "0%"},
+            {"OrderListHash", "721476625"}
+        };
+    }
+}

Algorithm.CSharp/AltData/QuiverWallStreetBetsDataAlgorithm.cs

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

Algorithm.CSharp/BacktestingBrokerageRegressionAlgorithm.cs

@@ -75,7 +75,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         /// <param name="data">Slice object keyed by symbol containing the stock data</param>
         public override void OnData(Slice data)
-        {   
+        {
             if (!_equityBought && data.ContainsKey(_spy)) {
                 //Buy our Equity
                 var quantity = CalculateOrderQuantity(_spy, .1m);
@@ -114,7 +114,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         /// <param name="orderEvent">OrderEvent object that contains all the information about the event</param>
         public override void OnOrderEvent(OrderEvent orderEvent)
-        {   
+        {
             // Get the order from our transactions
             var order = Transactions.GetOrderById(orderEvent.OrderId);
 
@@ -147,7 +147,7 @@ namespace QuantConnect.Algorithm.CSharp
 
                 // All PartiallyFilled orders should have a LastFillTime
                 case OrderStatus.PartiallyFilled:
-                    if (order.LastFillTime == null) 
+                    if (order.LastFillTime == null)
                     {
                         throw new Exception("LastFillTime should not be null");
                     }
@@ -183,9 +183,9 @@ namespace QuantConnect.Algorithm.CSharp
                 throw new Exception("OptionExercise order price should be strike price!!");
             }
 
-            if (orderEvent.Quantity != 1)
+            if (orderEvent.Quantity != -1)
             {
-                throw new Exception("OrderEvent Quantity should be 1");
+                throw new Exception("OrderEvent Quantity should be -1");
             }
         }
 
@@ -317,7 +317,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Treynor Ratio", "-0.018"},
             {"Total Fees", "$2.00"},
             {"Fitness Score", "0.213"},
-            {"OrderListHash", "-1514011542"}
+            {"OrderListHash", "904167951"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateAlgorithm.cs

@@ -119,4 +119,4 @@ namespace QuantConnect.Algorithm.CSharp
             {"OrderListHash", "491919591"}
         };
     }
-}
+}

Algorithm.CSharp/BasicTemplateCryptoAlgorithm.cs

@@ -242,7 +242,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "1073240275"}
+            {"OrderListHash", "415415696"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateOptionsFilterUniverseAlgorithm.cs

@@ -141,7 +141,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "1935621950"}
+            {"OrderListHash", "687310345"}
         };
     }
 }

Algorithm.CSharp/CancelOpenOrdersRegressionAlgorithm.cs

@@ -166,7 +166,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "-1708974186"}
+            {"OrderListHash", "737971736"}
         };
     }
 }

Algorithm.CSharp/CoarseFineOptionUniverseChainRegressionAlgorithm.cs

@@ -0,0 +1,189 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using QuantConnect.Data;
+using QuantConnect.Data.UniverseSelection;
+using QuantConnect.Interfaces;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Demonstration of how to chain a coarse and fine universe selection with an option chain universe selection model
+    /// that will add and remove an <see cref="OptionChainUniverse"/> for each symbol selected on fine
+    /// </summary>
+    public class CoarseFineOptionUniverseChainRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        // initialize our changes to nothing
+        private SecurityChanges _changes = SecurityChanges.None;
+        private int _optionCount;
+        private Symbol _lastEquityAdded;
+        private Symbol _aapl;
+        private Symbol _twx;
+
+        public override void Initialize()
+        {
+            _twx = QuantConnect.Symbol.Create("TWX", SecurityType.Equity, Market.USA);
+            _aapl = QuantConnect.Symbol.Create("AAPL", SecurityType.Equity, Market.USA);
+            UniverseSettings.Resolution = Resolution.Minute;
+
+            SetStartDate(2014, 06, 05);
+            SetEndDate(2014, 06, 06);
+
+            var selectionUniverse = AddUniverse(enumerable => new[] { Time.Date <= new DateTime(2014, 6, 5) ? _twx : _aapl },
+                enumerable => new[] { Time.Date <= new DateTime(2014, 6, 5) ? _twx : _aapl });
+
+            AddUniverseOptions(selectionUniverse, universe =>
+            {
+                if (universe.Underlying == null)
+                {
+                    throw new Exception("Underlying data point is null! This shouldn't happen, each OptionChainUniverse handles and should provide this");
+                }
+                return universe.IncludeWeeklys()
+                    .FrontMonth()
+                    .Contracts(universe.Take(5));
+            });
+        }
+
+        public override void OnData(Slice data)
+        {
+            // if we have no changes, do nothing
+            if (_changes == SecurityChanges.None ||
+                _changes.AddedSecurities.Any(security => security.Price == 0))
+            {
+                return;
+            }
+
+            // liquidate removed securities
+            foreach (var security in _changes.RemovedSecurities)
+            {
+                if (security.Invested)
+                {
+                    Liquidate(security.Symbol);
+                }
+            }
+
+            foreach (var security in _changes.AddedSecurities)
+            {
+                if (!security.Symbol.HasUnderlying)
+                {
+                    _lastEquityAdded = security.Symbol;
+                }
+                else
+                {
+                    // options added should all match prev added security
+                    if (security.Symbol.Underlying != _lastEquityAdded)
+                    {
+                        throw new Exception($"Unexpected symbol added {security.Symbol}");
+                    }
+
+                    _optionCount++;
+                }
+
+                SetHoldings(security.Symbol, 0.05m);
+
+                var config = SubscriptionManager.SubscriptionDataConfigService.GetSubscriptionDataConfigs(security.Symbol).ToList();
+
+                if (!config.Any())
+                {
+                    throw new Exception($"Was expecting configurations for {security.Symbol}");
+                }
+                if (config.Any(dataConfig => dataConfig.DataNormalizationMode != DataNormalizationMode.Raw))
+                {
+                    throw new Exception($"Was expecting DataNormalizationMode.Raw configurations for {security.Symbol}");
+                }
+            }
+            _changes = SecurityChanges.None;
+        }
+
+        public override void OnSecuritiesChanged(SecurityChanges changes)
+        {
+            _changes += changes;
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            var config = SubscriptionManager.Subscriptions.ToList();
+            if (config.Any(dataConfig => dataConfig.Symbol == _twx || dataConfig.Symbol.Underlying == _twx))
+            {
+                throw new Exception($"Was NOT expecting any configurations for {_twx} or it's options, since coarse/fine should have deselected it");
+            }
+
+            if (_optionCount == 0)
+            {
+                throw new Exception("Option universe chain did not add any option!");
+            }
+        }
+
+        /// <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", "13"},
+            {"Average Win", "0.65%"},
+            {"Average Loss", "-0.05%"},
+            {"Compounding Annual Return", "3216040423556140000000000%"},
+            {"Drawdown", "0.500%"},
+            {"Expectancy", "1.393"},
+            {"Net Profit", "32.840%"},
+            {"Sharpe Ratio", "7.14272222483913E+15"},
+            {"Probabilistic Sharpe Ratio", "0%"},
+            {"Loss Rate", "83%"},
+            {"Win Rate", "17%"},
+            {"Profit-Loss Ratio", "13.36"},
+            {"Alpha", "2.59468989671647E+16"},
+            {"Beta", "67.661"},
+            {"Annual Standard Deviation", "3.633"},
+            {"Annual Variance", "13.196"},
+            {"Information Ratio", "7.24987266907741E+15"},
+            {"Tracking Error", "3.579"},
+            {"Treynor Ratio", "383485597312030"},
+            {"Total Fees", "$13.00"},
+            {"Fitness Score", "0.232"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "79228162514264337593543950335"},
+            {"Return Over Maximum Drawdown", "79228162514264337593543950335"},
+            {"Portfolio Turnover", "0.232"},
+            {"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", "1630141557"}
+        };
+    }
+}

Algorithm.CSharp/CustomBuyingPowerModelAlgorithm.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 QuantConnect.Interfaces;
+using QuantConnect.Securities;
+using System.Collections.Generic;
+using QuantConnect.Data;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Demonstration of using custom buying power model in backtesting.
+    /// QuantConnect allows you to model all orders as deeply and accurately as you need.
+    /// </summary>
+    /// <meta name="tag" content="trading and orders" />
+    /// <meta name="tag" content="transaction fees and slippage" />
+    /// <meta name="tag" content="custom buying power models" />
+    public class CustomBuyingPowerModelAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Symbol _spy;
+
+        public override void Initialize()
+        {
+            SetStartDate(2013, 10, 01);
+            SetEndDate(2013, 10, 31);
+            var security = AddEquity("SPY", Resolution.Hour);
+            _spy = security.Symbol;
+
+            // set the buying power model
+            security.SetBuyingPowerModel(new CustomBuyingPowerModel());
+        }
+
+        public void OnData(Slice slice)
+        {
+            if (Portfolio.Invested)
+            {
+                return;
+            }
+
+            var quantity = CalculateOrderQuantity(_spy, 1m);
+            if (quantity % 100 != 0)
+            {
+                throw new Exception($"CustomBuyingPowerModel only allow quantity that is multiple of 100 and {quantity} was found");
+            }
+
+            // We normally get insufficient buying power model, but the
+            // CustomBuyingPowerModel always says that there is sufficient buying power for the orders
+            MarketOrder(_spy, quantity * 10);
+        }
+
+        public class CustomBuyingPowerModel : BuyingPowerModel
+        {
+            public override GetMaximumOrderQuantityResult GetMaximumOrderQuantityForTargetBuyingPower(
+                GetMaximumOrderQuantityForTargetBuyingPowerParameters parameters)
+            {
+                var quantity = base.GetMaximumOrderQuantityForTargetBuyingPower(parameters).Quantity;
+                quantity = Math.Floor(quantity / 100) * 100;
+                return new GetMaximumOrderQuantityResult(quantity);
+            }
+
+            public override HasSufficientBuyingPowerForOrderResult HasSufficientBuyingPowerForOrder(
+                HasSufficientBuyingPowerForOrderParameters parameters)
+            {
+                return new HasSufficientBuyingPowerForOrderResult(true);
+            }
+        }
+
+        /// <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", "5672.520%"},
+            {"Drawdown", "22.500%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "40.601%"},
+            {"Sharpe Ratio", "40.201"},
+            {"Probabilistic Sharpe Ratio", "77.339%"},
+            {"Loss Rate", "0%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "41.848"},
+            {"Beta", "9.224"},
+            {"Annual Standard Deviation", "1.164"},
+            {"Annual Variance", "1.355"},
+            {"Information Ratio", "44.459"},
+            {"Tracking Error", "1.04"},
+            {"Treynor Ratio", "5.073"},
+            {"Total Fees", "$30.00"},
+            {"Fitness Score", "0.418"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "113.05"},
+            {"Return Over Maximum Drawdown", "442.81"},
+            {"Portfolio Turnover", "0.418"},
+            {"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", "639761089"}
+        };
+    }
+}

Algorithm.CSharp/CustomModelsAlgorithm.cs

@@ -26,11 +26,12 @@ using QuantConnect.Securities;
 namespace QuantConnect.Algorithm.CSharp
 {
     /// <summary>
-    /// Demonstration of using custom fee, slippage and fill models for modelling transactions in backtesting.
+    /// Demonstration of using custom fee, slippage, fill, and buying power models for modelling transactions in backtesting.
     /// QuantConnect allows you to model all orders as deeply and accurately as you need.
     /// </summary>
     /// <meta name="tag" content="trading and orders" />
     /// <meta name="tag" content="transaction fees and slippage" />
+    /// <meta name="tag" content="custom buying power models" />
     /// <meta name="tag" content="custom transaction models" />
     /// <meta name="tag" content="custom slippage models" />
     /// <meta name="tag" content="custom fee models" />
@@ -50,6 +51,7 @@ namespace QuantConnect.Algorithm.CSharp
             _security.SetFeeModel(new CustomFeeModel(this));
             _security.SetFillModel(new CustomFillModel(this));
             _security.SetSlippageModel(new CustomSlippageModel(this));
+            _security.SetBuyingPowerModel(new CustomBuyingPowerModel(this));
         }
 
         public void OnData(TradeBars data)
@@ -60,13 +62,13 @@ namespace QuantConnect.Algorithm.CSharp
             if (Time.Day > 10 && _security.Holdings.Quantity <= 0)
             {
                 var quantity = CalculateOrderQuantity(_spy, .5m);
-                Log("MarketOrder: " + quantity);
+                Log($"MarketOrder: {quantity}");
                 MarketOrder(_spy, quantity, asynchronous: true); // async needed for partial fill market orders
             }
             else if (Time.Day > 20 && _security.Holdings.Quantity >= 0)
             {
                 var quantity = CalculateOrderQuantity(_spy, -.5m);
-                Log("MarketOrder: " + quantity);
+                Log($"MarketOrder: {quantity}");
                 MarketOrder(_spy, quantity, asynchronous: true); // async needed for partial fill market orders
             }
         }
@@ -109,7 +111,7 @@ namespace QuantConnect.Algorithm.CSharp
                     fill.Status = OrderStatus.PartiallyFilled;
                 }
 
-                _algorithm.Log("CustomFillModel: " + fill);
+                _algorithm.Log($"CustomFillModel: {fill}");
 
                 return fill;
             }
@@ -131,7 +133,7 @@ namespace QuantConnect.Algorithm.CSharp
                     1m,
                     parameters.Security.Price*parameters.Order.AbsoluteQuantity*0.00001m);
 
-                _algorithm.Log("CustomFeeModel: " + fee);
+                _algorithm.Log($"CustomFeeModel: {fee}");
                 return new OrderFee(new CashAmount(fee, "USD"));
             }
         }
@@ -150,11 +152,31 @@ namespace QuantConnect.Algorithm.CSharp
                 // custom slippage math
                 var slippage = asset.Price*0.0001m*(decimal) Math.Log10(2*(double) order.AbsoluteQuantity);
 
-                _algorithm.Log("CustomSlippageModel: " + slippage);
+                _algorithm.Log($"CustomSlippageModel: {slippage}");
                 return slippage;
             }
         }
 
+        public class CustomBuyingPowerModel : BuyingPowerModel
+        {
+            private readonly QCAlgorithm _algorithm;
+
+            public CustomBuyingPowerModel(QCAlgorithm algorithm)
+            {
+                _algorithm = algorithm;
+            }
+
+            public override HasSufficientBuyingPowerForOrderResult HasSufficientBuyingPowerForOrder(
+                HasSufficientBuyingPowerForOrderParameters parameters)
+            {
+                // custom behavior: this model will assume that there is always enough buying power
+                var hasSufficientBuyingPowerForOrderResult = new HasSufficientBuyingPowerForOrderResult(true);
+                _algorithm.Log($"CustomBuyingPowerModel: {hasSufficientBuyingPowerForOrderResult.IsSufficient}");
+
+                return hasSufficientBuyingPowerForOrderResult;
+            }
+        }
+
         /// <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>

Algorithm.CSharp/DropboxBaseDataUniverseSelectionAlgorithm.cs

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

Algorithm.CSharp/DropboxUniverseSelectionAlgorithm.cs

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

Algorithm.CSharp/EquityTickQuoteAdjustedModeRegressionAlgorithm.cs

@@ -0,0 +1,128 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
+using System;
+using System.Collections.Generic;
+using QuantConnect.Data;
+using QuantConnect.Interfaces;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Checks that the Tick BidPrice and AskPrices are adjusted like Value.
+    /// </summary>
+    public class EquityTickQuoteAdjustedModeRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Symbol _ibm;
+        private bool _bought;
+        private bool _sold;
+
+        public override void Initialize()
+        {
+            SetStartDate(2013, 10, 7);
+            SetEndDate(2013, 10, 11);
+            SetCash(100000);
+
+            _ibm = AddEquity("IBM", Resolution.Tick).Symbol;
+        }
+
+        public override void OnData(Slice data)
+        {
+            if (!data.Ticks.ContainsKey(_ibm))
+            {
+                return;
+            }
+
+            var security = Securities[_ibm];
+            if (!security.HasData)
+            {
+                return;
+            }
+
+            foreach (var tick in data.Ticks[_ibm])
+            {
+                if (tick.BidPrice != 0 && !_bought && ((tick.Value - tick.BidPrice) <= 0.05m))
+                {
+                    SetHoldings(_ibm, 1);
+                    _bought = true;
+                    return;
+                }
+                if (tick.AskPrice != 0 && _bought && !_sold && Math.Abs((double)tick.Value - (double)tick.AskPrice) <= 0.05)
+                {
+                    Liquidate(_ibm);
+                    _sold = true;
+                    return;
+                }
+            }
+        }
+
+        /// <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", "0%"},
+            {"Average Loss", "-0.01%"},
+            {"Compounding Annual Return", "-0.500%"},
+            {"Drawdown", "0.000%"},
+            {"Expectancy", "-1"},
+            {"Net Profit", "-0.006%"},
+            {"Sharpe Ratio", "0"},
+            {"Probabilistic Sharpe Ratio", "0%"},
+            {"Loss Rate", "100%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "0"},
+            {"Beta", "0"},
+            {"Annual Standard Deviation", "0"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "-8.769"},
+            {"Tracking Error", "0.22"},
+            {"Treynor Ratio", "0"},
+            {"Total Fees", "$6.41"},
+            {"Fitness Score", "0.248"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "79228162514264337593543950335"},
+            {"Return Over Maximum Drawdown", "-82.815"},
+            {"Portfolio Turnover", "0.497"},
+            {"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", "1213851303"}
+        };
+    }
+}

Algorithm.CSharp/ExtendedMarketHoursHistoryRegressionAlgorithm.cs

@@ -0,0 +1,172 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
+using System;
+using System.Linq;
+using QuantConnect.Data;
+using QuantConnect.Interfaces;
+using System.Collections.Generic;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Regression algorithm testing doing some history requests outside market hours, reproducing GH issue #4783
+    /// </summary>
+    public class ExtendedMarketHoursHistoryRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private int _minuteHistoryCount;
+        private int _hourHistoryCount;
+        private int _dailyHistoryCount;
+
+        /// <summary>
+        /// Initialise the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must initialized.
+        /// </summary>
+        public override void Initialize()
+        {
+            SetStartDate(2013, 10, 07);
+            SetEndDate(2013, 10, 09);
+            SetCash(100000);
+
+            AddEquity("SPY", Resolution.Minute, extendedMarketHours:true, fillDataForward:false);
+
+            Schedule.On("RunHistoryCall", DateRules.EveryDay(), TimeRules.Every(TimeSpan.FromHours(1)), RunHistoryCall);
+        }
+
+        private void RunHistoryCall()
+        {
+            var spy = Securities["SPY"];
+            var regularHours = spy.Exchange.Hours.IsOpen(Time, false);
+            var extendedHours = !regularHours && spy.Exchange.Hours.IsOpen(Time, true);
+
+            if (regularHours)
+            {
+                _minuteHistoryCount++;
+                var history = History(spy.Symbol, 5, Resolution.Minute).Count();
+                if (history != 5)
+                {
+                    throw new Exception($"Unexpected Minute data count: {history}");
+                }
+            }
+            else
+            {
+                if (extendedHours)
+                {
+                    _hourHistoryCount++;
+                    var history = History(spy.Symbol, 5, Resolution.Hour).Count();
+                    if (history != 5)
+                    {
+                        throw new Exception($"Unexpected Hour data count {history}");
+                    }
+                }
+                else
+                {
+                    _dailyHistoryCount++;
+                    var history = History(spy.Symbol, 5, Resolution.Daily).Count();
+                    if (history != 5)
+                    {
+                        throw new Exception($"Unexpected Daily data count {history}");
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here.
+        /// </summary>
+        /// <param name="data">Slice object keyed by symbol containing the stock data</param>
+        public override void OnData(Slice data)
+        {
+            if (!Portfolio.Invested)
+            {
+                SetHoldings("SPY", 1);
+            }
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            if (_minuteHistoryCount != 3 * 6)
+            {
+                throw new Exception($"Unexpected minute history requests count {_minuteHistoryCount}");
+            }
+            // 6 pre market from 4am to 9am + 4 post market 4pm to 7pm
+            if (_hourHistoryCount != 3 * 10)
+            {
+                throw new Exception($"Unexpected hour history requests count {_hourHistoryCount}");
+            }
+            // 0am to 3am + 8pm to 11pm, last day ends at 8pm
+            if (_dailyHistoryCount != (2 * 8 + 5))
+            {
+                throw new Exception($"Unexpected Daily history requests count: {_dailyHistoryCount}");
+            }
+        }
+
+        /// <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", "20"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0.00%"},
+            {"Compounding Annual Return", "-74.182%"},
+            {"Drawdown", "2.200%"},
+            {"Expectancy", "-1"},
+            {"Net Profit", "-1.046%"},
+            {"Sharpe Ratio", "-8.269"},
+            {"Probabilistic Sharpe Ratio", "0%"},
+            {"Loss Rate", "100%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "-0.19"},
+            {"Beta", "0.579"},
+            {"Annual Standard Deviation", "0.065"},
+            {"Annual Variance", "0.004"},
+            {"Information Ratio", "1.326"},
+            {"Tracking Error", "0.049"},
+            {"Treynor Ratio", "-0.934"},
+            {"Total Fees", "$22.26"},
+            {"Fitness Score", "0.002"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "-11.855"},
+            {"Return Over Maximum Drawdown", "-70.945"},
+            {"Portfolio Turnover", "0.342"},
+            {"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", "-1961710414"}
+        };
+    }
+}

Algorithm.CSharp/ExtendedMarketTradingRegressionAlgorithm.cs

@@ -141,7 +141,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "699698796"}
+            {"OrderListHash", "1717552327"}
         };
     }
 }

Algorithm.CSharp/HistoryWithSymbolChangesRegressionAlgorithm.cs

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

Algorithm.CSharp/LimitFillRegressionAlgorithm.cs

@@ -119,7 +119,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "1459983342"}
+            {"OrderListHash", "187652813"}
         };
     }
 }

Algorithm.CSharp/MaximumPortfolioDrawdownFrameworkAlgorithm.cs

@@ -65,32 +65,32 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
-            {"Total Trades", "2"},
+            {"Total Trades", "5"},
             {"Average Win", "0%"},
-            {"Average Loss", "-0.98%"},
-            {"Compounding Annual Return", "-53.792%"},
-            {"Drawdown", "1.500%"},
+            {"Average Loss", "-0.52%"},
+            {"Compounding Annual Return", "246.602%"},
+            {"Drawdown", "2.300%"},
             {"Expectancy", "-1"},
-            {"Net Profit", "-0.982%"},
-            {"Sharpe Ratio", "-5.949"},
-            {"Probabilistic Sharpe Ratio", "1.216%"},
+            {"Net Profit", "1.602%"},
+            {"Sharpe Ratio", "8.065"},
+            {"Probabilistic Sharpe Ratio", "65.943%"},
             {"Loss Rate", "100%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "-0.973"},
-            {"Beta", "0.268"},
-            {"Annual Standard Deviation", "0.077"},
-            {"Annual Variance", "0.006"},
-            {"Information Ratio", "-14.167"},
-            {"Tracking Error", "0.168"},
-            {"Treynor Ratio", "-1.705"},
-            {"Total Fees", "$6.51"},
-            {"Fitness Score", "0.249"},
+            {"Alpha", "-0.157"},
+            {"Beta", "1.015"},
+            {"Annual Standard Deviation", "0.223"},
+            {"Annual Variance", "0.05"},
+            {"Information Ratio", "-27.079"},
+            {"Tracking Error", "0.005"},
+            {"Treynor Ratio", "1.772"},
+            {"Total Fees", "$16.28"},
+            {"Fitness Score", "0.999"},
             {"Kelly Criterion Estimate", "38.64"},
             {"Kelly Criterion Probability Value", "0.229"},
             {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "-55.465"},
-            {"Portfolio Turnover", "0.498"},
+            {"Return Over Maximum Drawdown", "78.607"},
+            {"Portfolio Turnover", "1.246"},
             {"Total Insights Generated", "100"},
             {"Total Insights Closed", "99"},
             {"Total Insights Analysis Completed", "99"},
@@ -104,7 +104,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "54.5455%"},
             {"Rolling Averaged Population Direction", "59.8056%"},
             {"Rolling Averaged Population Magnitude", "59.8056%"},
-            {"OrderListHash", "160051570"}
+            {"OrderListHash", "-1552239367"}
         };
     }
 }

Algorithm.CSharp/OptionAssignmentRegressionAlgorithm.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 System.Collections.Generic;
+using System.Linq;
+using QuantConnect.Data;
+using QuantConnect.Interfaces;
+using QuantConnect.Securities;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// This regression algorithm verifies automatic option contract assignment behavior.
+    /// </summary>
+    /// <meta name="tag" content="regression test" />
+    /// <meta name="tag" content="options" />
+    /// <meta name="tag" content="using data" />
+    /// <meta name="tag" content="filter selection" />
+    public class OptionAssignmentRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Security Stock;
+
+        private Security CallOption;
+        private Symbol CallOptionSymbol;
+
+        private Security PutOption;
+        private Symbol PutOptionSymbol;
+
+        public override void Initialize()
+        {
+            SetStartDate(2015, 12, 23);
+            SetEndDate(2015, 12, 24);
+            SetCash(100000);
+            Stock = AddEquity("GOOG", Resolution.Minute);
+
+            var contracts = OptionChainProvider.GetOptionContractList(Stock.Symbol, UtcTime).ToList();
+
+            PutOptionSymbol = contracts
+                .Where(c => c.ID.OptionRight == OptionRight.Put)
+                .OrderBy(c => c.ID.Date)
+                .First(c => c.ID.StrikePrice == 800m);
+
+            CallOptionSymbol = contracts
+                .Where(c => c.ID.OptionRight == OptionRight.Call)
+                .OrderBy(c => c.ID.Date)
+                .First(c => c.ID.StrikePrice == 600m);
+
+            PutOption = AddOptionContract(PutOptionSymbol);
+            CallOption = AddOptionContract(CallOptionSymbol);
+        }
+
+        public override void OnData(Slice data)
+        {
+            if (!Portfolio.Invested && Stock.Price != 0 && PutOption.Price != 0 && CallOption.Price != 0)
+            {
+                // this gets executed on start and after each auto-assignment, finally ending with expiration assignment
+                MarketOrder(PutOptionSymbol, -1);
+                MarketOrder(CallOptionSymbol, -1);
+            }
+        }
+
+        public bool CanRunLocally { get; } = true;
+        public Language[] Languages { get; } = {Language.CSharp};
+
+        public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        {
+            {"Total Trades", "22"},
+            {"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", "$12.00"},
+            {"Fitness Score", "0.5"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "79228162514264337593543950335"},
+            {"Return Over Maximum Drawdown", "-50.218"},
+            {"Portfolio Turnover", "6.713"},
+            {"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", "-1597098916"}
+        };
+    }
+}

Algorithm.CSharp/OptionChainProviderAlgorithm.cs

@@ -21,7 +21,7 @@ using QuantConnect.Interfaces;
 namespace QuantConnect.Algorithm.CSharp
 {
     /// <summary>
-    /// Demonstration of the Option Chain Provider -- a much faster mechanism for manually specifying the option contracts you'd like to recieve
+    /// Demonstration of the Option Chain Provider -- a much faster mechanism for manually specifying the option contracts you'd like to receive
     /// data for and manually subscribing to them.
     /// </summary>
     /// <meta name="tag" content="strategy example" />

Algorithm.CSharp/OptionChainedAndUniverseSelectionRegressionAlgorithm.cs

@@ -0,0 +1,142 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
+using System;
+using System.Linq;
+using QuantConnect.Data;
+using QuantConnect.Interfaces;
+using System.Collections.Generic;
+using QuantConnect.Algorithm.Framework.Selection;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Regression algorithm making sure that the added universe selection does not remove the option chain during it's daily refresh
+    /// </summary>
+    public class OptionChainedAndUniverseSelectionRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Symbol _aaplOption;
+
+        public override void Initialize()
+        {
+            UniverseSettings.Resolution = Resolution.Minute;
+
+            SetStartDate(2014, 06, 05);
+            SetEndDate(2014, 06, 09);
+
+            _aaplOption = AddOption("AAPL").Symbol;
+            AddUniverseSelection(new DailyUniverseSelectionModel("MyCustomSelectionModel", time => new[] { "AAPL" }, this));
+        }
+
+        public override void OnData(Slice data)
+        {
+            if (!Portfolio.Invested)
+            {
+                Buy("AAPL", 1);
+            }
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            var config = SubscriptionManager.Subscriptions.ToList();
+            if (config.All(dataConfig => dataConfig.Symbol != "AAPL"))
+            {
+                throw new Exception("Was expecting configurations for AAPL");
+            }
+            if (config.All(dataConfig => dataConfig.Symbol.SecurityType != SecurityType.Option))
+            {
+                throw new Exception($"Was expecting configurations for {_aaplOption}");
+            }
+        }
+
+        private class DailyUniverseSelectionModel : CustomUniverseSelectionModel
+        {
+            private DateTime _lastRefresh;
+            private IAlgorithm _algorithm;
+
+            public DailyUniverseSelectionModel(string name, Func<DateTime, IEnumerable<string>> selector, IAlgorithm algorithm) : base(name, selector)
+            {
+                _algorithm = algorithm;
+            }
+
+            public override DateTime GetNextRefreshTimeUtc()
+            {
+                if (_lastRefresh != _algorithm.Time.Date)
+                {
+                    _lastRefresh = _algorithm.Time.Date;
+                    return DateTime.MinValue;
+                }
+                return DateTime.MaxValue;
+            }
+        }
+
+        /// <summary>
+        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
+        /// </summary>
+        public bool CanRunLocally { get; } = true;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public Language[] Languages { get; } = { Language.CSharp };
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        {
+            {"Total Trades", "1"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "0.678%"},
+            {"Drawdown", "3.700%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "0.009%"},
+            {"Sharpe Ratio", "7.969"},
+            {"Probabilistic Sharpe Ratio", "0%"},
+            {"Loss Rate", "0%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "0.046"},
+            {"Beta", "-0.032"},
+            {"Annual Standard Deviation", "0.001"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "-24.461"},
+            {"Tracking Error", "0.044"},
+            {"Treynor Ratio", "-0.336"},
+            {"Total Fees", "$1.00"},
+            {"Fitness Score", "0.003"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "79228162514264337593543950335"},
+            {"Return Over Maximum Drawdown", "79228162514264337593543950335"},
+            {"Portfolio Turnover", "0.003"},
+            {"Total Insights Generated", "0"},
+            {"Total Insights Closed", "0"},
+            {"Total Insights Analysis Completed", "0"},
+            {"Long Insight Count", "0"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "$0"},
+            {"Total Accumulated Estimated Alpha Value", "$0"},
+            {"Mean Population Estimated Insight Value", "$0"},
+            {"Mean Population Direction", "0%"},
+            {"Mean Population Magnitude", "0%"},
+            {"Rolling Averaged Population Direction", "0%"},
+            {"Rolling Averaged Population Magnitude", "0%"},
+            {"OrderListHash", "-1779427412"}
+        };
+    }
+}

Algorithm.CSharp/OptionExerciseAssignRegressionAlgorithm.cs

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

Algorithm.CSharp/OptionRenameRegressionAlgorithm.cs

@@ -56,6 +56,13 @@ namespace QuantConnect.Algorithm.CSharp
         /// <param name="slice">The current slice of data keyed by symbol string</param>
         public override void OnData(Slice slice)
         {
+            foreach (var dividend in slice.Dividends.Values)
+            {
+                if (dividend.ReferencePrice != 32.59m || dividend.Distribution != 3.82m)
+                {
+                    throw new Exception($"{Time} - Invalid dividend {dividend}");
+                }
+            }
             if (!Portfolio.Invested)
             {
                 if (Time.Day == 28 && Time.Hour > 9 && Time.Minute > 0)
@@ -139,11 +146,11 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "4"},
             {"Average Win", "0%"},
             {"Average Loss", "-0.02%"},
-            {"Compounding Annual Return", "-0.453%"},
+            {"Compounding Annual Return", "-0.492%"},
             {"Drawdown", "0.000%"},
             {"Expectancy", "-1"},
             {"Net Profit", "-0.006%"},
-            {"Sharpe Ratio", "-3.554"},
+            {"Sharpe Ratio", "-3.943"},
             {"Probabilistic Sharpe Ratio", "0%"},
             {"Loss Rate", "100%"},
             {"Win Rate", "0%"},
@@ -152,15 +159,15 @@ namespace QuantConnect.Algorithm.CSharp
             {"Beta", "0"},
             {"Annual Standard Deviation", "0.002"},
             {"Annual Variance", "0"},
-            {"Information Ratio", "-3.554"},
+            {"Information Ratio", "-3.943"},
             {"Tracking Error", "0.002"},
             {"Treynor Ratio", "0"},
             {"Total Fees", "$4.00"},
-            {"Fitness Score", "0.001"},
+            {"Fitness Score", "0"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
             {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "-1.768"},
+            {"Return Over Maximum Drawdown", "-2.808"},
             {"Portfolio Turnover", "0.001"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},

Algorithm.CSharp/QuantConnect.Algorithm.CSharp.csproj

@@ -142,8 +142,18 @@
       <Link>Properties\SharedAssemblyInfo.cs</Link>
     </Compile>
     <Compile Include="AddAlphaModelAlgorithm.cs" />
+    <Compile Include="CustomBuyingPowerModelAlgorithm.cs" />
+    <Compile Include="AddOptionContractExpiresRegressionAlgorithm.cs" />
+    <Compile Include="AltData\QuiverWallStreetBetsDataAlgorithm.cs" />
+    <Compile Include="ScaledFillForwardDataRegressionAlgorithm.cs" />
     <Compile Include="DailyHistoryForDailyResolutionRegressionAlgorithm.cs" />
     <Compile Include="DailyHistoryForMinuteResolutionRegressionAlgorithm.cs" />
+    <Compile Include="ExtendedMarketHoursHistoryRegressionAlgorithm.cs" />
+    <Compile Include="EquityTickQuoteAdjustedModeRegressionAlgorithm.cs" />
+    <Compile Include="AddOptionContractFromUniverseRegressionAlgorithm.cs" />
+    <Compile Include="CoarseFineOptionUniverseChainRegressionAlgorithm.cs" />
+    <Compile Include="OptionChainedAndUniverseSelectionRegressionAlgorithm.cs" />
+    <Compile Include="OptionAssignmentRegressionAlgorithm.cs" />
     <Compile Include="SwitchDataModeRegressionAlgorithm.cs" />
     <Compile Include="AddRemoveOptionUniverseRegressionAlgorithm.cs" />
     <Compile Include="AddRemoveSecurityRegressionAlgorithm.cs" />

Algorithm.CSharp/ScaledFillForwardDataRegressionAlgorithm.cs

@@ -0,0 +1,143 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using QuantConnect.Data;
+using QuantConnect.Data.Market;
+using QuantConnect.Interfaces;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// This regression test algorithm reproduces issue https://github.com/QuantConnect/Lean/issues/4834
+    /// fixed in PR https://github.com/QuantConnect/Lean/pull/4836
+    /// Adjusted data of fill forward bars should use original scale factor
+    /// </summary>
+    public class ScaledFillForwardDataRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private TradeBar _lastRealBar;
+        private Symbol _twx;
+        public override void Initialize()
+        {
+            SetStartDate(2014, 6, 5);
+            SetEndDate(2014, 6, 9);
+
+            _twx = AddEquity("TWX", Resolution.Minute, extendedMarketHours: true).Symbol;
+            Schedule.On(DateRules.EveryDay(_twx), TimeRules.Every(TimeSpan.FromHours(1)), PlotPrice);
+        }
+
+        private void PlotPrice()
+        {
+            Plot($"{_twx}", "Ask", Securities[_twx].AskPrice);
+            Plot($"{_twx}", "Bid", Securities[_twx].BidPrice);
+            Plot($"{_twx}", "Price", Securities[_twx].Price);
+            Plot("Portfolio.TPV", "Value", Portfolio.TotalPortfolioValue);
+        }
+
+        public override void OnData(Slice data)
+        {
+            var current = data.Bars.FirstOrDefault().Value;
+            if (current != null)
+            {
+                if (Time == new DateTime(2014, 06, 09, 4, 1, 0) && !Portfolio.Invested)
+                {
+                    if (!current.IsFillForward)
+                    {
+                        throw new Exception($"Was expecting a first fill forward bar {Time}");
+                    }
+
+                    // trade on the first bar after a factor price scale change. +10 so we fill ASAP. Limit so it fills in extended market hours
+                    LimitOrder(_twx, 1000, _lastRealBar.Close + 10);
+                }
+
+                if (_lastRealBar == null || !current.IsFillForward)
+                {
+                    _lastRealBar = current;
+                }
+                else if (_lastRealBar.Close != current.Close)
+                {
+                    throw new Exception($"FillForwarded data point at {Time} was scaled. Actual: {current.Close}; Expected: {_lastRealBar.Close}");
+                }
+            }
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            if (_lastRealBar == null)
+            {
+                throw new Exception($"Not all expected data points were received.");
+            }
+        }
+
+        /// <summary>
+        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
+        /// </summary>
+        public bool CanRunLocally { get; } = true;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public Language[] Languages { get; } = { Language.CSharp };
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        {
+            {"Total Trades", "1"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "32.825%"},
+            {"Drawdown", "0.800%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "0.377%"},
+            {"Sharpe Ratio", "8.953"},
+            {"Probabilistic Sharpe Ratio", "95.977%"},
+            {"Loss Rate", "0%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "0.314"},
+            {"Beta", "-0.104"},
+            {"Annual Standard Deviation", "0.03"},
+            {"Annual Variance", "0.001"},
+            {"Information Ratio", "-3.498"},
+            {"Tracking Error", "0.05"},
+            {"Treynor Ratio", "-2.573"},
+            {"Total Fees", "$5.00"},
+            {"Fitness Score", "0.158"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "79228162514264337593543950335"},
+            {"Return Over Maximum Drawdown", "79228162514264337593543950335"},
+            {"Portfolio Turnover", "0.158"},
+            {"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", "960108217"}
+        };
+    }
+}

Algorithm.CSharp/SwitchDataModeRegressionAlgorithm.cs

@@ -64,7 +64,7 @@ namespace QuantConnect.Algorithm.CSharp
         {
             if (_expectedCloseValues.Count > 0)
             {
-                throw new Exception($"Not all expected data points were recieved.");
+                throw new Exception($"Not all expected data points were received.");
             }
         }
 

Algorithm.CSharp/TimeInForceAlgorithm.cs

@@ -189,7 +189,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "-569072921"}
+            {"OrderListHash", "359885308"}
         };
     }
 }

Algorithm.CSharp/TotalPortfolioValueRegressionAlgorithm.cs

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

Algorithm.CSharp/UniverseSelectionRegressionAlgorithm.cs

@@ -172,32 +172,32 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
-            {"Total Trades", "5"},
+            {"Total Trades", "4"},
             {"Average Win", "0.64%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "-74.197%"},
-            {"Drawdown", "6.600%"},
+            {"Compounding Annual Return", "-56.577%"},
+            {"Drawdown", "3.800%"},
             {"Expectancy", "0"},
-            {"Net Profit", "-6.115%"},
-            {"Sharpe Ratio", "-2.281"},
-            {"Probabilistic Sharpe Ratio", "11.870%"},
+            {"Net Profit", "-3.811%"},
+            {"Sharpe Ratio", "-2.773"},
+            {"Probabilistic Sharpe Ratio", "13.961%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "100%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "-0.684"},
-            {"Beta", "-0.113"},
-            {"Annual Standard Deviation", "0.292"},
-            {"Annual Variance", "0.085"},
-            {"Information Ratio", "-1.606"},
-            {"Tracking Error", "0.312"},
-            {"Treynor Ratio", "5.866"},
-            {"Total Fees", "$5.00"},
-            {"Fitness Score", "0.017"},
+            {"Alpha", "-0.504"},
+            {"Beta", "-0.052"},
+            {"Annual Standard Deviation", "0.179"},
+            {"Annual Variance", "0.032"},
+            {"Information Ratio", "-1.599"},
+            {"Tracking Error", "0.207"},
+            {"Treynor Ratio", "9.508"},
+            {"Total Fees", "$4.00"},
+            {"Fitness Score", "0.008"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "-2.584"},
-            {"Return Over Maximum Drawdown", "-11.287"},
-            {"Portfolio Turnover", "0.177"},
+            {"Sortino Ratio", "-3.791"},
+            {"Return Over Maximum Drawdown", "-14.846"},
+            {"Portfolio Turnover", "0.136"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
             {"Total Insights Analysis Completed", "0"},
@@ -211,7 +211,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "-1386253041"}
+            {"OrderListHash", "1484950465"}
         };
     }
 }

Algorithm.Framework/Risk/MaximumDrawdownPercentPortfolio.cs

@@ -67,9 +67,11 @@ namespace QuantConnect.Algorithm.Framework.Risk
             }
 
             var pnl = GetTotalDrawdownPercent(currentValue);
-            if (pnl < _maximumDrawdownPercent)
+            if (pnl < _maximumDrawdownPercent && targets.Length != 0)
             {
-                foreach(var target in targets)
+                // reset the trailing high value for restart investing on next rebalcing period
+                _initialised = false;
+                foreach (var target in targets)
                     yield return new PortfolioTarget(target.Symbol, 0);
             }
         }

Algorithm.Framework/Risk/MaximumDrawdownPercentPortfolio.py

@@ -54,10 +54,11 @@ class MaximumDrawdownPercentPortfolio(RiskManagementModel):
             return []   # return if new high reached
 
         pnl = self.GetTotalDrawdownPercent(currentValue)
-        if pnl < self.maximumDrawdownPercent:
+        if pnl < self.maximumDrawdownPercent and len(targets) != 0:
+            self.initialised = False # reset the trailing high value for restart investing on next rebalcing period
             return [ PortfolioTarget(target.Symbol, 0) for target in targets ]
 
         return []
 
     def GetTotalDrawdownPercent(self, currentValue):
-        return (float(currentValue) / float(self.portfolioHigh)) - 1.0
+        return (float(currentValue) / float(self.portfolioHigh)) - 1.0

Algorithm.Framework/Selection/OptionUniverseSelectionModel.cs

@@ -15,12 +15,9 @@
 
 using System;
 using System.Collections.Generic;
-using QuantConnect.Data;
-using QuantConnect.Data.Auxiliary;
 using QuantConnect.Data.UniverseSelection;
 using QuantConnect.Interfaces;
 using QuantConnect.Securities;
-using QuantConnect.Securities.Option;
 
 namespace QuantConnect.Algorithm.Framework.Selection
 {
@@ -107,53 +104,11 @@ namespace QuantConnect.Algorithm.Framework.Selection
                 // prevent creating duplicate option chains -- one per underlying
                 if (uniqueUnderlyingSymbols.Add(optionSymbol.Underlying))
                 {
-                    yield return CreateOptionChain(algorithm, optionSymbol);
+                    yield return algorithm.CreateOptionChain(optionSymbol, Filter, _universeSettings);
                 }
             }
         }
 
-        /// <summary>
-        /// Creates the canonical <see cref="Option"/> chain security for a given symbol
-        /// </summary>
-        /// <param name="algorithm">The algorithm instance to create universes for</param>
-        /// <param name="symbol">Symbol of the option</param>
-        /// <param name="settings">Universe settings define attributes of created subscriptions, such as their resolution and the minimum time in universe before they can be removed</param>
-        /// <param name="initializer">Performs extra initialization (such as setting models) after we create a new security object</param>
-        /// <returns><see cref="Option"/> for the given symbol</returns>
-        [Obsolete("This method is obsolete because SecurityInitializer is obsolete and will not be used.")]
-        protected virtual Option CreateOptionChainSecurity(QCAlgorithm algorithm, Symbol symbol, UniverseSettings settings, ISecurityInitializer initializer)
-        {
-            return CreateOptionChainSecurity(
-                algorithm.SubscriptionManager.SubscriptionDataConfigService,
-                symbol,
-                settings,
-                algorithm.Securities);
-        }
-
-        /// <summary>
-        /// Creates the canonical <see cref="Option"/> chain security for a given symbol
-        /// </summary>
-        /// <param name="subscriptionDataConfigService">The service used to create new <see cref="SubscriptionDataConfig"/></param>
-        /// <param name="symbol">Symbol of the option</param>
-        /// <param name="settings">Universe settings define attributes of created subscriptions, such as their resolution and the minimum time in universe before they can be removed</param>
-        /// <param name="securityManager">Used to create new <see cref="Security"/></param>
-        /// <returns><see cref="Option"/> for the given symbol</returns>
-        protected virtual Option CreateOptionChainSecurity(
-            ISubscriptionDataConfigService subscriptionDataConfigService,
-            Symbol symbol,
-            UniverseSettings settings,
-            SecurityManager securityManager)
-        {
-            var config = subscriptionDataConfigService.Add(
-                typeof(ZipEntryName),
-                symbol,
-                settings.Resolution,
-                settings.FillForward,
-                settings.ExtendedMarketHours,
-                false);
-            return (Option)securityManager.CreateSecurity(symbol, config, settings.Leverage, false);
-        }
-
         /// <summary>
         /// Defines the option chain universe filter
         /// </summary>
@@ -162,55 +117,5 @@ namespace QuantConnect.Algorithm.Framework.Selection
             // NOP
             return filter;
         }
-
-        /// <summary>
-        /// Creates a <see cref="OptionChainUniverse"/> for a given symbol
-        /// </summary>
-        /// <param name="algorithm">The algorithm instance to create universes for</param>
-        /// <param name="symbol">Symbol of the option</param>
-        /// <returns><see cref="OptionChainUniverse"/> for the given symbol</returns>
-        private OptionChainUniverse CreateOptionChain(QCAlgorithm algorithm, Symbol symbol)
-        {
-            if (symbol.SecurityType != SecurityType.Option)
-            {
-                throw new ArgumentException("CreateOptionChain requires an option symbol.");
-            }
-
-            // rewrite non-canonical symbols to be canonical
-            var market = symbol.ID.Market;
-            var underlying = symbol.Underlying;
-            if (!symbol.IsCanonical())
-            {
-                var alias = $"?{underlying.Value}";
-                symbol = Symbol.Create(underlying.Value, SecurityType.Option, market, alias);
-            }
-
-            // resolve defaults if not specified
-            var settings = _universeSettings ?? algorithm.UniverseSettings;
-
-            // create canonical security object, but don't duplicate if it already exists
-            Security security;
-            Option optionChain;
-            if (!algorithm.Securities.TryGetValue(symbol, out security))
-            {
-                optionChain = CreateOptionChainSecurity(
-                    algorithm.SubscriptionManager.SubscriptionDataConfigService,
-                    symbol,
-                    settings,
-                    algorithm.Securities);
-            }
-            else
-            {
-                optionChain = (Option)security;
-            }
-
-            // set the option chain contract filter function
-            optionChain.SetFilter(Filter);
-
-            // force option chain security to not be directly tradable AFTER it's configured to ensure it's not overwritten
-            optionChain.IsTradable = false;
-
-            return new OptionChainUniverse(optionChain, settings, algorithm.LiveMode);
-        }
     }
 }

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

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

Algorithm.Python/.idea/misc.xml

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

Algorithm.Python/.idea/modules.xml

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

Algorithm.Python/.vscode/settings.json

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

Algorithm.Python/AddOptionContractExpiresRegressionAlgorithm.py

@@ -0,0 +1,67 @@
+# 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 *
+
+### <summary>
+### We add an option contract using 'QCAlgorithm.AddOptionContract' and place a trade, the underlying
+### gets deselected from the universe selection but should still be present since we manually added the option contract.
+### Later we call 'QCAlgorithm.RemoveOptionContract' and expect both option and underlying to be removed.
+### </summary>
+class AddOptionContractExpiresRegressionAlgorithm(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, 6, 5)
+        self.SetEndDate(2014, 6, 30)
+
+        self._expiration = datetime(2014, 6, 21)
+        self._option = None
+        self._traded = False
+
+        self._twx = Symbol.Create("TWX", SecurityType.Equity, Market.USA)
+
+        self.AddUniverse("my-daily-universe-name", self.Selector)
+
+    def Selector(self, time):
+        return [ "AAPL" ]
+
+    def OnData(self, data):
+        '''OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here.
+
+        Arguments:
+            data: Slice object keyed by symbol containing the stock data
+        '''
+        if self._option == None:
+            options = self.OptionChainProvider.GetOptionContractList(self._twx, self.Time)
+            options = sorted(options, key=lambda x: x.ID.Symbol)
+
+            option = next((option for option in options if option.ID.Date == self._expiration and option.ID.OptionRight == OptionRight.Call and option.ID.OptionStyle == OptionStyle.American), None)
+            if option != None:
+                self._option = self.AddOptionContract(option).Symbol;
+
+        if self._option != None and self.Securities[self._option].Price != 0 and not self._traded:
+            self._traded = True;
+            self.Buy(self._option, 1);
+
+        if self.Time > self._expiration and self.Securities[self._twx].Invested:
+                # we liquidate the option exercised position
+                self.Liquidate(self._twx);

Algorithm.Python/AddOptionContractFromUniverseRegressionAlgorithm.py

@@ -0,0 +1,87 @@
+# 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 *
+
+### <summary>
+### We add an option contract using 'QCAlgorithm.AddOptionContract' and place a trade, the underlying
+### gets deselected from the universe selection but should still be present since we manually added the option contract.
+### Later we call 'QCAlgorithm.RemoveOptionContract' and expect both option and underlying to be removed.
+### </summary>
+class AddOptionContractFromUniverseRegressionAlgorithm(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, 6, 5)
+        self.SetEndDate(2014, 6, 9)
+
+        self._expiration = datetime(2014, 6, 21)
+        self._securityChanges = None
+        self._option = None
+        self._traded = False
+
+        self._twx = Symbol.Create("TWX", SecurityType.Equity, Market.USA)
+        self._aapl = Symbol.Create("AAPL", SecurityType.Equity, Market.USA)
+        self.UniverseSettings.Resolution = Resolution.Minute
+        self.UniverseSettings.DataNormalizationMode = DataNormalizationMode.Raw
+
+        self.AddUniverse(self.Selector, self.Selector)
+
+    def Selector(self, fundamental):
+        if self.Time <= datetime(2014, 6, 5):
+            return  [ self._twx ]
+        return [ self._aapl ]
+
+    def OnData(self, data):
+        '''OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here.
+
+        Arguments:
+            data: Slice object keyed by symbol containing the stock data
+        '''
+        if self._option != None and self.Securities[self._option].Price != 0 and not self._traded:
+            self._traded = True;
+            self.Buy(self._option, 1);
+
+        if self.Time == datetime(2014, 6, 6, 14, 0, 0):
+            # liquidate & remove the option
+            self.RemoveOptionContract(self._option)
+
+    def OnSecuritiesChanged(self, changes):
+        # keep track of all removed and added securities
+        if self._securityChanges == None:
+            self._securityChanges = changes
+        else:
+            self._securityChanges.op_Addition(self._securityChanges, changes)
+
+        if any(security.Symbol.SecurityType == SecurityType.Option for security in changes.AddedSecurities):
+            return
+
+        for addedSecurity in changes.AddedSecurities:
+            options = self.OptionChainProvider.GetOptionContractList(addedSecurity.Symbol, self.Time)
+            options = sorted(options, key=lambda x: x.ID.Symbol)
+
+            option = next((option for option in options if option.ID.Date == self._expiration and option.ID.OptionRight == OptionRight.Call and option.ID.OptionStyle == OptionStyle.American), None)
+
+            self.AddOptionContract(option)
+
+            # just keep the first we got
+            if self._option == None:
+                self._option = option

Algorithm.Python/AltData/QuiverWallStreetBetsDataAlgorithm.py

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

Algorithm.Python/CoarseFineOptionUniverseChainRegressionAlgorithm.py

@@ -0,0 +1,99 @@
+# 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("System.Collections")
+AddReference("QuantConnect.Common")
+AddReference("QuantConnect.Algorithm")
+
+from System import *
+from QuantConnect import *
+from QuantConnect.Algorithm import *
+from QuantConnect.Data.UniverseSelection import *
+from datetime import *
+
+### <summary>
+### Demonstration of how to chain a coarse and fine universe selection with an option chain universe selection model
+### that will add and remove an'OptionChainUniverse' for each symbol selected on fine
+### </summary>
+class CoarseFineOptionUniverseChainRegressionAlgorithm(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,6,5)  #Set Start Date
+        self.SetEndDate(2014,6,6)    #Set End Date
+
+        self.UniverseSettings.Resolution = Resolution.Minute
+        self._twx = Symbol.Create("TWX", SecurityType.Equity, Market.USA)
+        self._aapl = Symbol.Create("AAPL", SecurityType.Equity, Market.USA)
+        self._lastEquityAdded = None
+        self._changes = None
+        self._optionCount = 0
+
+        universe = self.AddUniverse(self.CoarseSelectionFunction, self.FineSelectionFunction)
+        
+        self.AddUniverseOptions(universe, self.OptionFilterFunction)
+
+    def OptionFilterFunction(self, universe):
+        universe.IncludeWeeklys().FrontMonth()
+
+        contracts = list()
+        for symbol in universe:
+            if len(contracts) == 5:
+                break
+            contracts.append(symbol)
+        return universe.Contracts(contracts)
+
+    def CoarseSelectionFunction(self, coarse):
+        if self.Time <= datetime(2014,6,5):
+            return [ self._twx ]
+        return [ self._aapl ]
+
+    def FineSelectionFunction(self, fine):
+        if self.Time <= datetime(2014,6,5):
+            return [ self._twx ]
+        return [ self._aapl ]
+
+    def OnData(self, data):
+        if self._changes == None or any(security.Price == 0 for security in self._changes.AddedSecurities):
+            return
+
+        # liquidate removed securities
+        for security in self._changes.RemovedSecurities:
+            if security.Invested:
+                self.Liquidate(security.Symbol);
+
+        for security in self._changes.AddedSecurities:
+            if not security.Symbol.HasUnderlying:
+                self._lastEquityAdded = security.Symbol;
+            else:
+                # options added should all match prev added security
+                if security.Symbol.Underlying != self._lastEquityAdded:
+                    raise ValueError(f"Unexpected symbol added {security.Symbol}")
+                self._optionCount += 1
+
+            self.SetHoldings(security.Symbol, 0.05)
+        self._changes = None
+
+    # this event fires whenever we have changes to our universe
+    def OnSecuritiesChanged(self, changes):
+        if self._changes == None:
+            self._changes = changes
+            return
+        self._changes = self._changes.op_Addition(self._changes, changes)
+
+    def OnEndOfAlgorithm(self):
+        if self._optionCount == 0:
+            raise ValueError("Option universe chain did not add any option!")

Algorithm.Python/ConsolidateRegressionAlgorithm.py

@@ -22,7 +22,6 @@ from QuantConnect import *
 from QuantConnect.Algorithm import *
 from QuantConnect.Indicators import *
 from QuantConnect.Securities import *
-from QuantConnect.Data.Market import *
 from QuantConnect.Data.Consolidators import *
 from CustomDataRegressionAlgorithm import Bitcoin
 from datetime import timedelta

Algorithm.Python/CustomBuyingPowerModelAlgorithm.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 QuantConnect.Securities import *
+import numpy as np
+
+### <summary>
+### Demonstration of using custom buying power model in backtesting.
+### QuantConnect allows you to model all orders as deeply and accurately as you need.
+### </summary>
+### <meta name="tag" content="trading and orders" />
+### <meta name="tag" content="transaction fees and slippage" />
+### <meta name="tag" content="custom buying power models" />
+class CustomBuyingPowerModelAlgorithm(QCAlgorithm):
+    '''Demonstration of using custom buying power model in backtesting.
+    QuantConnect allows you to model all orders as deeply and accurately as you need.'''
+
+    def Initialize(self):
+        self.SetStartDate(2013,10,1)   # Set Start Date
+        self.SetEndDate(2013,10,31)    # Set End Date
+        security = self.AddEquity("SPY", Resolution.Hour)
+        self.spy = security.Symbol
+
+        # set the buying power model
+        security.SetBuyingPowerModel(CustomBuyingPowerModel())
+
+    def OnData(self, slice):
+        if self.Portfolio.Invested:
+            return
+
+        quantity = self.CalculateOrderQuantity(self.spy, 1)
+        if quantity % 100 != 0:
+            raise Exception(f'CustomBuyingPowerModel only allow quantity that is multiple of 100 and {quantity} was found')
+
+        # We normally get insufficient buying power model, but the
+        # CustomBuyingPowerModel always says that there is sufficient buying power for the orders
+        self.MarketOrder(self.spy, quantity * 10)
+
+
+class CustomBuyingPowerModel(BuyingPowerModel):
+    def GetMaximumOrderQuantityForTargetBuyingPower(self, parameters):
+        quantity = super().GetMaximumOrderQuantityForTargetBuyingPower(parameters).Quantity
+        quantity = np.floor(quantity / 100) * 100
+        return GetMaximumOrderQuantityResult(quantity)
+
+    def HasSufficientBuyingPowerForOrder(self, parameters):
+        return HasSufficientBuyingPowerForOrderResult(True)

Algorithm.Python/CustomConsolidatorRegressionAlgorithm.py

@@ -13,19 +13,18 @@
 
 from clr import AddReference
 AddReference("System")
+AddReference("QuantConnect.Common")
 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.Market import *
 from QuantConnect.Data.Consolidators import *
 from QuantConnect.Indicators import *
-from QuantConnect.Data.Market import *
+from System import *
 from datetime import *
 
 class CustomConsolidatorRegressionAlgorithm(QCAlgorithm):

Algorithm.Python/CustomDataAddDataCoarseSelectionRegressionAlgorithm.py

@@ -21,6 +21,7 @@ from QuantConnect import *
 from QuantConnect.Algorithm import *
 from QuantConnect.Algorithm.Framework.Selection import *
 from QuantConnect.Data import *
+from QuantConnect.Data.Custom import *
 from QuantConnect.Data.Custom.SEC import *
 from QuantConnect.Data.UniverseSelection import *
 

Algorithm.Python/CustomModelsAlgorithm.py

@@ -27,16 +27,17 @@ import numpy as np
 import random
 
 ### <summary>
-### Demonstration of using custom fee, slippage and fill models for modelling transactions in backtesting.
+### Demonstration of using custom fee, slippage, fill, and buying power models for modelling transactions in backtesting.
 ### QuantConnect allows you to model all orders as deeply and accurately as you need.
 ### </summary>
 ### <meta name="tag" content="trading and orders" />
 ### <meta name="tag" content="transaction fees and slippage" />
+### <meta name="tag" content="custom buying power models" />
 ### <meta name="tag" content="custom transaction models" />
 ### <meta name="tag" content="custom slippage models" />
 ### <meta name="tag" content="custom fee models" />
 class CustomModelsAlgorithm(QCAlgorithm):
-    '''Demonstration of using custom fee, slippage and fill models for modelling transactions in backtesting.
+    '''Demonstration of using custom fee, slippage, fill, and buying power models for modelling transactions in backtesting.
     QuantConnect allows you to model all orders as deeply and accurately as you need.'''
 
     def Initialize(self):
@@ -49,6 +50,7 @@ class CustomModelsAlgorithm(QCAlgorithm):
         self.security.SetFeeModel(CustomFeeModel(self))
         self.security.SetFillModel(CustomFillModel(self))
         self.security.SetSlippageModel(CustomSlippageModel(self))
+        self.security.SetBuyingPowerModel(CustomBuyingPowerModel(self))
 
 
     def OnData(self, data):
@@ -57,12 +59,12 @@ class CustomModelsAlgorithm(QCAlgorithm):
 
         if self.Time.day > 10 and self.security.Holdings.Quantity <= 0:
             quantity = self.CalculateOrderQuantity(self.spy, .5)
-            self.Log("MarketOrder: " + str(quantity))
+            self.Log(f"MarketOrder: {quantity}")
             self.MarketOrder(self.spy, quantity, True)   # async needed for partial fill market orders
 
         elif self.Time.day > 20 and self.security.Holdings.Quantity >= 0:
             quantity = self.CalculateOrderQuantity(self.spy, -.5)
-            self.Log("MarketOrder: " + str(quantity))
+            self.Log(f"MarketOrder: {quantity}")
             self.MarketOrder(self.spy, quantity, True)   # async needed for partial fill market orders
 
 # If we want to use methods from other models, you need to inherit from one of them
@@ -90,7 +92,7 @@ class CustomFillModel(ImmediateFillModel):
             absoluteRemaining = absoluteRemaining - absoluteFillQuantity
             self.absoluteRemainingByOrderId[order.Id] = absoluteRemaining
             fill.Status = OrderStatus.PartiallyFilled
-        self.algorithm.Log("CustomFillModel: " + str(fill))
+        self.algorithm.Log(f"CustomFillModel: {fill}")
         return fill
 
 class CustomFeeModel(FeeModel):
@@ -102,7 +104,7 @@ class CustomFeeModel(FeeModel):
         fee = max(1, parameters.Security.Price
                   * parameters.Order.AbsoluteQuantity
                   * 0.00001)
-        self.algorithm.Log("CustomFeeModel: " + str(fee))
+        self.algorithm.Log(f"CustomFeeModel: {fee}")
         return OrderFee(CashAmount(fee, "USD"))
 
 class CustomSlippageModel:
@@ -112,5 +114,15 @@ class CustomSlippageModel:
     def GetSlippageApproximation(self, asset, order):
         # custom slippage math
         slippage = asset.Price * 0.0001 * np.log10(2*float(order.AbsoluteQuantity))
-        self.algorithm.Log("CustomSlippageModel: " + str(slippage))
-        return slippage
+        self.algorithm.Log(f"CustomSlippageModel: {slippage}")
+        return slippage
+
+class CustomBuyingPowerModel(BuyingPowerModel):
+    def __init__(self, algorithm):
+        self.algorithm = algorithm
+
+    def HasSufficientBuyingPowerForOrder(self, parameters):
+        # custom behavior: this model will assume that there is always enough buying power
+        hasSufficientBuyingPowerForOrderResult = HasSufficientBuyingPowerForOrderResult(True)
+        self.algorithm.Log(f"CustomBuyingPowerModel: {hasSufficientBuyingPowerForOrderResult.IsSufficient}")
+        return hasSufficientBuyingPowerForOrderResult

Algorithm.Python/InceptionDateSelectionRegressionAlgorithm.py

@@ -12,15 +12,15 @@
 # limitations under the License.
 
 from clr import AddReference
-AddReference("System.Core")
-AddReference("QuantConnect.Common")
+AddReference("System")
 AddReference("QuantConnect.Algorithm")
-AddReference("QuantConnect.Algorithm.Framework")
+AddReference("QuantConnect.Common")
 
 from System import *
 from QuantConnect import *
-from QuantConnect.Algorithm import QCAlgorithm
+from QuantConnect.Algorithm import *
 from QuantConnect.Algorithm.Framework.Selection import *
+from QuantConnect.Data import *
 from QuantConnect.Data.UniverseSelection import *
 from datetime import timedelta
 

Algorithm.Python/LongOnlyAlphaStreamAlgorithm.py

@@ -14,7 +14,6 @@
 from clr import AddReference
 AddReference("System")
 AddReference("QuantConnect.Algorithm")
-AddReference("QuantConnect.Algorithm.Framework")
 AddReference("QuantConnect.Common")
 
 from QuantConnect import *
@@ -24,7 +23,6 @@ from QuantConnect.Algorithm.Framework.Execution import *
 from QuantConnect.Algorithm.Framework.Portfolio import *
 from QuantConnect.Algorithm.Framework.Selection import *
 from QuantConnect.Brokerages import *
-from QuantConnect.Data import *
 from QuantConnect.Interfaces import *
 from QuantConnect.Orders import *
 from System import *

Algorithm.Python/QuantConnect.Algorithm.Python.csproj

@@ -46,6 +46,8 @@
   <ItemGroup>
     <Content Include="AccumulativeInsightPortfolioRegressionAlgorithm.py" />
     <Content Include="AddAlphaModelAlgorithm.py" />
+    <Content Include="AddOptionContractExpiresRegressionAlgorithm.py" />
+    <Content Include="AddOptionContractFromUniverseRegressionAlgorithm.py" />
     <Content Include="AddRiskManagementAlgorithm.py" />
     <Content Include="AddUniverseSelectionModelAlgorithm.py" />
     <Content Include="Alphas\ContingentClaimsAnalysisDefaultPredictionAlpha.py" />
@@ -63,6 +65,7 @@
     <Content Include="Alphas\VIXDualThrustAlpha.py" />
     <Content Include="AltData\CachedAlternativeDataAlgorithm.py" />
     <Content Include="AltData\BenzingaNewsAlgorithm.py" />
+    <Content Include="AltData\QuiverWallStreetBetsDataAlgorithm.py" />
     <Content Include="AltData\SECReport8KAlgorithm.py" />
     <Content Include="AltData\SmartInsiderTransactionAlgorithm.py" />
     <Content Include="AltData\USTreasuryYieldCurveRateAlgorithm.py" />
@@ -83,11 +86,13 @@
     <None Include="BasicTemplateOptionsPriceModel.py" />
     <Content Include="Benchmarks\SECReportBenchmarkAlgorithm.py" />
     <Content Include="Benchmarks\SmartInsiderEventBenchmarkAlgorithm.py" />
+    <Content Include="CoarseFineOptionUniverseChainRegressionAlgorithm.py" />
     <Content Include="CoarseTiingoNewsUniverseSelectionAlgorithm.py" />
     <Content Include="ConsolidateRegressionAlgorithm.py" />
     <Content Include="CustomConsolidatorRegressionAlgorithm.py" />
     <Content Include="CustomDataAddDataOnSecuritiesChangedRegressionAlgorithm.py" />
     <Content Include="CustomDataAddDataCoarseSelectionRegressionAlgorithm.py" />
+    <None Include="CustomBuyingPowerModelAlgorithm.py" />
     <Content Include="DynamicSecurityDataAlgorithm.py" />
     <Content Include="ConfidenceWeightedFrameworkAlgorithm.py" />
     <Content Include="ExtendedMarketTradingRegressionAlgorithm.py" />

Algorithm.Python/QuantConnect.Algorithm.PythonTools.pyproj

@@ -6,7 +6,8 @@
     <ProjectHome>.</ProjectHome>
     <StartupFile>
     </StartupFile>
-    <SearchPath>stubs</SearchPath>
+    <SearchPath>
+    </SearchPath>
     <WorkingDirectory>.</WorkingDirectory>
     <OutputPath>.</OutputPath>
     <Name>QuantConnect.Algorithm.PythonTools</Name>
@@ -45,6 +46,7 @@
     <Compile Include="ConstituentsQC500GeneratorAlgorithm.py" />
     <Compile Include="ConstituentsUniverseRegressionAlgorithm.py" />
     <Compile Include="ConvertToFrameworkAlgorithm.py" />
+    <Compile Include="CustomBuyingPowerModelAlgorithm.py" />
     <Compile Include="CustomDataAddDataCoarseSelectionRegressionAlgorithm.py" />
     <Compile Include="CustomDataAddDataOnSecuritiesChangedRegressionAlgorithm.py" />
     <Compile Include="CustomDataAddDataRegressionAlgorithm.py" />

Algorithm.Python/readme.md

@@ -1,6 +1,24 @@
 QuantConnect Python Algorithm Project:
 =============
 
+## Local Python Autocomplete
+To enable autocomplete for your local Python IDE, install the `quantconnect-stubs` package from PyPI using the following command:
+```
+pip install quantconnect-stubs
+```
+
+To update your autocomplete to the latest version, you can run the following command:
+```
+pip install --upgrade quantconnect-stubs
+```
+
+Copy and paste the imports found [here](#python-autocomplete-imports) to the top of your project file to enable autocomplete.
+
+In addition, you can use [Skylight](https://www.quantconnect.com/skylight) to automatically sync local changes to the cloud.
+
+------
+
+## Running LEAN Locally with Python
 Before we enable python support, follow the [installation instructions](https://github.com/QuantConnect/Lean#installation-instructions) to get LEAN running C# algorithms in your machine. 
 
 ### Install Python 3.6:
@@ -24,16 +42,14 @@ Before we enable python support, follow the [installation instructions](https://
 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:
-1. Find `libpython3.6m.dylib` in your Python installation folder. If you installed Python with Anaconda, it may be find at
-```
-/Users/{your_user_name}/anaconda3/lib/libpython3.6m.dylib
-```
-2. Open `Lean/Launcher/bin/Debug/Python.Runtime.dll.config`, add the following text and save:
-```
- <configuration>
-    <dllmap dll="python3.6m" target="{the path in step 1 including libpython3.6m.dylib}" os="!windows"/>
-</configuration>
-```
+1. Find `libpython3.6m.dylib` in your Python installation folder. If you installed Python with Anaconda, it may be found at
+    ```
+    /Users/{your_user_name}/anaconda3/lib/libpython3.6m.dylib
+    ```
+2. Open `Lean/Launcher/bin/Debug/Python.Runtime.dll.config`, add the following text under `<configuration> ... </configuration>` and save:
+    ```
+        <dllmap dll="python3.6m" target="{the path in step 1 including libpython3.6m.dylib}" os="osx"/>
+    ```
 Note: Specify the install of v3.6.8 _exactly_, i.e. if with conda `conda install python=3.6.8` as this is a known compatible version and other versions may have issues as of this writing. 
 
 #### [Linux](https://github.com/QuantConnect/Lean#linux-debian-ubuntu)
@@ -50,23 +66,38 @@ conda install -y pandas=0.25.3
 conda install -y wrapt=1.11.2
 ```
 
-*Note:* There is a [known issue](https://github.com/pythonnet/pythonnet/issues/609) with python 3.6.5 that prevents pythonnet installation, please upgrade python to version 3.6.8:
-```
-conda install -y python=3.6.8
-```
+*Note 1:* There is a [known issue](https://github.com/pythonnet/pythonnet/issues/609) with python 3.6.5 that prevents pythonnet installation, please upgrade python to version 3.6.8:
+    ```
+    conda install -y python=3.6.8
+    ```
+    
+*Note 2:* If you encounter the "System.DllNotFoundException: python3.6m" runtime error when running Python algorithms on Linux:
+1. Find `libpython3.6m.so` in your Python installation folder. If you installed Python with Miniconda, it may be found at
+    ```
+    /home/{your_user_name}/miniconda3/envs/{qc_environment}/lib/libpython3.6m.so
+    ```
+   Note that you can create a new virtual environment with all required dependencies by executing:
+   ```
+   conda create -n qc_environment python=3.6.8 cython=0.29.11 pandas=0.25.3 wrapt=1.11.2
 
+   ```
+2. Open `Lean/Launcher/bin/Debug/Python.Runtime.dll.config`, add the following text under `<configuration> ... </configuration>` and save:
+    ```
+        <dllmap dll="python3.6m" target="{the path in step 1 including libpython3.6m.so}" os="linux"/>
+    ```
 ### Run python algorithm
 1. Update the [config](https://github.com/QuantConnect/Lean/blob/master/Launcher/config.json) to run the python algorithm:
-```json
-"algorithm-type-name": "BasicTemplateAlgorithm",
-"algorithm-language": "Python",
-"algorithm-location": "../../../Algorithm.Python/BasicTemplateAlgorithm.py",
-```
+    ```json
+    "algorithm-type-name": "BasicTemplateAlgorithm",
+    "algorithm-language": "Python",
+    "algorithm-location": "../../../Algorithm.Python/BasicTemplateAlgorithm.py",
+    ```
  2. Rebuild LEAN.
  3. Run LEAN. You should see the same result of the C# algorithm you tested earlier.
 
 ___
-#### Python.Runtime.dll compilation
+
+### Python.NET development - Python.Runtime.dll compilation
 LEAN users do **not** need to compile `Python.Runtime.dll`. The information below is targeted to developers who wish to improve it. 
 
 Download [QuantConnect/pythonnet](https://github.com/QuantConnect/pythonnet/) github clone or downloading the zip. If downloading the zip - unzip to a local pathway.
@@ -87,3 +118,45 @@ msbuild pythonnet.sln /nologo /v:quiet /t:Clean;Rebuild /p:Platform=x64 /p:Pytho
 ```
 msbuild pythonnet.sln /nologo /v:quiet /t:Clean;Rebuild /p:Platform=x64 /p:PythonInteropFile="interop36m.cs" /p:Configuration=ReleaseMono /p:DefineConstants="PYTHON36,PYTHON3,UCS4,MONO_LINUX,PYTHON_WITH_PYMALLOC"
 ```
+
+# Python Autocomplete Imports
+Copy and paste these imports to the top of your Python file to enable a development experience equal to the cloud (these imports are exactly the same as the ones used in the QuantConnect Terminal).
+
+```python
+from QuantConnect import *
+from QuantConnect.Parameters import *
+from QuantConnect.Benchmarks import *
+from QuantConnect.Brokerages import *
+from QuantConnect.Util import *
+from QuantConnect.Interfaces import *
+from QuantConnect.Algorithm import *
+from QuantConnect.Algorithm.Framework import *
+from QuantConnect.Algorithm.Framework.Selection import *
+from QuantConnect.Algorithm.Framework.Alphas import *
+from QuantConnect.Algorithm.Framework.Portfolio import *
+from QuantConnect.Algorithm.Framework.Execution import *
+from QuantConnect.Algorithm.Framework.Risk import *
+from QuantConnect.Indicators import *
+from QuantConnect.Data import *
+from QuantConnect.Data.Consolidators import *
+from QuantConnect.Data.Custom import *
+from QuantConnect.Data.Fundamental import *
+from QuantConnect.Data.Market import *
+from QuantConnect.Data.UniverseSelection import *
+from QuantConnect.Notifications import *
+from QuantConnect.Orders import *
+from QuantConnect.Orders.Fees import *
+from QuantConnect.Orders.Fills import *
+from QuantConnect.Orders.Slippage import *
+from QuantConnect.Scheduling import *
+from QuantConnect.Securities import *
+from QuantConnect.Securities.Equity import *
+from QuantConnect.Securities.Forex import *
+from QuantConnect.Securities.Interfaces import *
+from datetime import date, datetime, timedelta
+from QuantConnect.Python import *
+from QuantConnect.Storage import *
+QCAlgorithmFramework = QCAlgorithm
+QCAlgorithmFrameworkBridge = QCAlgorithm
+```
+

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

@@ -1,402 +0,0 @@
-# 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

@@ -1,26 +0,0 @@
-# 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

@@ -1,45 +0,0 @@
-# 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

@@ -1,210 +0,0 @@
-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

@@ -1,85 +0,0 @@
-# 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

@@ -1,272 +0,0 @@
-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

@@ -1,100 +0,0 @@
-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

@@ -1,226 +0,0 @@
-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

@@ -1,109 +0,0 @@
-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

@@ -1,149 +0,0 @@
-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

@@ -1,174 +0,0 @@
-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

@@ -1,195 +0,0 @@
-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

@@ -1,153 +0,0 @@
-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

@@ -1,158 +0,0 @@
-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

@@ -1,243 +0,0 @@
-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

@@ -1,58 +0,0 @@
-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

@@ -1,184 +0,0 @@
-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

@@ -1,165 +0,0 @@
-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

@@ -1,110 +0,0 @@
-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

@@ -1,56 +0,0 @@
-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

@@ -1,265 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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

@@ -1,233 +0,0 @@
-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

@@ -1,139 +0,0 @@
-# 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

@@ -1,51 +0,0 @@
-# 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

@@ -1,279 +0,0 @@
-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

@@ -1,335 +0,0 @@
-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

@@ -1,312 +0,0 @@
-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

@@ -1,138 +0,0 @@
-# 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

@@ -1,61 +0,0 @@
-# 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

@@ -1,284 +0,0 @@
-# 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

@@ -1,157 +0,0 @@
-# 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

@@ -1,109 +0,0 @@
-# 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

@@ -1,299 +0,0 @@
-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

@@ -1,345 +0,0 @@
-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

@@ -1,216 +0,0 @@
-# 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

@@ -1,297 +0,0 @@
-# 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

@@ -1,78 +0,0 @@
-# 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

@@ -1,92 +0,0 @@
-# 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

@@ -1,39 +0,0 @@
-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