quantconnect-stubs 17357__py3-none-any.whl → 17410__py3-none-any.whl

Common/Util/__init__.py

@@ -0,0 +1,32 @@
+import os
+import sys
+
+# If quantconnect-stubs is installed via pip and Lean is ran locally,
+# importing anything from the current namespace makes the Python
+# interpreter look in the quantconnect-stubs package for the implementation.
+#
+# The desired behavior is for the interpreter to use the implementation
+# provided by the AddReference() call from Python.NET.
+#
+# To fix this, we temporarily remove the directory containing the
+# quantconnect-stubs package from sys.path and re-import the current namespace
+# so the relevant C# namespace is used when running Lean locally.
+
+# Find the directory containing quantconnect-stubs (usually site-packages)
+current_path = os.path.dirname(__file__)
+while os.path.basename(current_path) != "Common":
+    current_path = os.path.dirname(current_path)
+current_path = os.path.dirname(current_path)
+
+# Temporarily remove the directory containing quantconnect-stubs from sys.path
+original_path = sys.path[:]
+sys.path.remove(current_path)
+
+# Import the C# version of the current namespace
+del sys.modules["Common.Util"]
+from clr import AddReference
+AddReference("Common.Util")
+from Common.Util import *
+
+# Restore sys.path
+sys.path = original_path

Common/Util/__init__.pyi

@@ -0,0 +1,152 @@
+from typing import overload
+from enum import IntEnum
+import typing
+
+import Common.Util
+import QuantConnect
+import System.Collections.Generic
+
+Common_Util_ReadOnlyExtendedDictionary_TValue = typing.TypeVar("Common_Util_ReadOnlyExtendedDictionary_TValue")
+Common_Util_ReadOnlyExtendedDictionary_TKey = typing.TypeVar("Common_Util_ReadOnlyExtendedDictionary_TKey")
+Common_Util_BaseExtendedDictionary_TDictionary = typing.TypeVar("Common_Util_BaseExtendedDictionary_TDictionary")
+Common_Util_BaseExtendedDictionary_TKey = typing.TypeVar("Common_Util_BaseExtendedDictionary_TKey")
+Common_Util_BaseExtendedDictionary_TValue = typing.TypeVar("Common_Util_BaseExtendedDictionary_TValue")
+
+
+class ReadOnlyExtendedDictionary(typing.Generic[Common_Util_ReadOnlyExtendedDictionary_TKey, Common_Util_ReadOnlyExtendedDictionary_TValue], Common.Util.BaseExtendedDictionary[Common_Util_ReadOnlyExtendedDictionary_TKey, Common_Util_ReadOnlyExtendedDictionary_TValue], System.Collections.Generic.IReadOnlyDictionary[Common_Util_ReadOnlyExtendedDictionary_TKey, Common_Util_ReadOnlyExtendedDictionary_TValue]):
+    """This class has no documentation."""
+
+    @property
+    def is_read_only(self) -> bool:
+        ...
+
+    def __getitem__(self, key: Common_Util_ReadOnlyExtendedDictionary_TKey) -> Common_Util_ReadOnlyExtendedDictionary_TValue:
+        ...
+
+    @overload
+    def __init__(self) -> None:
+        ...
+
+    @overload
+    def __init__(self, dictionary: System.Collections.Generic.IDictionary[Common_Util_ReadOnlyExtendedDictionary_TKey, Common_Util_ReadOnlyExtendedDictionary_TValue]) -> None:
+        ...
+
+    @overload
+    def __init__(self, data: System.Collections.Generic.IEnumerable[Common_Util_ReadOnlyExtendedDictionary_TValue], key_selector: typing.Callable[[Common_Util_ReadOnlyExtendedDictionary_TValue], Common_Util_ReadOnlyExtendedDictionary_TKey]) -> None:
+        ...
+
+    def __setitem__(self, key: Common_Util_ReadOnlyExtendedDictionary_TKey, value: Common_Util_ReadOnlyExtendedDictionary_TValue) -> None:
+        ...
+
+    @overload
+    def add(self, key: Common_Util_ReadOnlyExtendedDictionary_TKey, value: Common_Util_ReadOnlyExtendedDictionary_TValue) -> None:
+        ...
+
+    @overload
+    def add(self, item: System.Collections.Generic.KeyValuePair[Common_Util_ReadOnlyExtendedDictionary_TKey, Common_Util_ReadOnlyExtendedDictionary_TValue]) -> None:
+        ...
+
+    def clear(self) -> None:
+        ...
+
+    @overload
+    def remove(self, key: Common_Util_ReadOnlyExtendedDictionary_TKey) -> bool:
+        ...
+
+    @overload
+    def remove(self, item: System.Collections.Generic.KeyValuePair[Common_Util_ReadOnlyExtendedDictionary_TKey, Common_Util_ReadOnlyExtendedDictionary_TValue]) -> bool:
+        ...
+
+
+class BaseExtendedDictionary(typing.Generic[Common_Util_BaseExtendedDictionary_TKey, Common_Util_BaseExtendedDictionary_TValue, Common_Util_BaseExtendedDictionary_TDictionary], QuantConnect.ExtendedDictionary[Common_Util_BaseExtendedDictionary_TKey, Common_Util_BaseExtendedDictionary_TValue], System.Collections.Generic.IDictionary[Common_Util_BaseExtendedDictionary_TKey, Common_Util_BaseExtendedDictionary_TValue], typing.Iterable[System.Collections.Generic.KeyValuePair[Common_Util_BaseExtendedDictionary_TKey, Common_Util_BaseExtendedDictionary_TValue]]):
+    """This class has no documentation."""
+
+    @property
+    def dictionary(self) -> Common_Util_BaseExtendedDictionary_TDictionary:
+        ...
+
+    @property
+    def count(self) -> int:
+        ...
+
+    @property
+    def is_read_only(self) -> bool:
+        ...
+
+    @property
+    def get_keys(self) -> typing.Iterable[Common_Util_BaseExtendedDictionary_TKey]:
+        ...
+
+    @property
+    def get_values(self) -> typing.Iterable[Common_Util_BaseExtendedDictionary_TValue]:
+        ...
+
+    def __contains__(self, key: Common_Util_BaseExtendedDictionary_TKey) -> bool:
+        ...
+
+    def __getitem__(self, key: Common_Util_BaseExtendedDictionary_TKey) -> Common_Util_BaseExtendedDictionary_TValue:
+        ...
+
+    @overload
+    def __init__(self) -> None:
+        ...
+
+    @overload
+    def __init__(self, dictionary: Common_Util_BaseExtendedDictionary_TDictionary) -> None:
+        ...
+
+    @overload
+    def __init__(self, data: System.Collections.Generic.IEnumerable[Common_Util_BaseExtendedDictionary_TValue], key_selector: typing.Callable[[Common_Util_BaseExtendedDictionary_TValue], Common_Util_BaseExtendedDictionary_TKey]) -> None:
+        ...
+
+    @overload
+    def __init__(self, dictionary: System.Collections.Generic.IDictionary[Common_Util_BaseExtendedDictionary_TKey, Common_Util_BaseExtendedDictionary_TValue]) -> None:
+        ...
+
+    def __iter__(self) -> typing.Iterator[System.Collections.Generic.KeyValuePair[Common_Util_BaseExtendedDictionary_TKey, Common_Util_BaseExtendedDictionary_TValue]]:
+        ...
+
+    def __len__(self) -> int:
+        ...
+
+    def __setitem__(self, key: Common_Util_BaseExtendedDictionary_TKey, value: Common_Util_BaseExtendedDictionary_TValue) -> None:
+        ...
+
+    @overload
+    def add(self, key: Common_Util_BaseExtendedDictionary_TKey, value: Common_Util_BaseExtendedDictionary_TValue) -> None:
+        ...
+
+    @overload
+    def add(self, item: System.Collections.Generic.KeyValuePair[Common_Util_BaseExtendedDictionary_TKey, Common_Util_BaseExtendedDictionary_TValue]) -> None:
+        ...
+
+    def clear(self) -> None:
+        ...
+
+    def contains(self, item: System.Collections.Generic.KeyValuePair[Common_Util_BaseExtendedDictionary_TKey, Common_Util_BaseExtendedDictionary_TValue]) -> bool:
+        ...
+
+    def contains_key(self, key: Common_Util_BaseExtendedDictionary_TKey) -> bool:
+        ...
+
+    def copy_to(self, array: typing.List[System.Collections.Generic.KeyValuePair[Common_Util_BaseExtendedDictionary_TKey, Common_Util_BaseExtendedDictionary_TValue]], array_index: int) -> None:
+        ...
+
+    def get_enumerator(self) -> System.Collections.Generic.IEnumerator[System.Collections.Generic.KeyValuePair[Common_Util_BaseExtendedDictionary_TKey, Common_Util_BaseExtendedDictionary_TValue]]:
+        ...
+
+    def get_items(self) -> System.Collections.Generic.IEnumerable[System.Collections.Generic.KeyValuePair[Common_Util_BaseExtendedDictionary_TKey, Common_Util_BaseExtendedDictionary_TValue]]:
+        ...
+
+    @overload
+    def remove(self, key: Common_Util_BaseExtendedDictionary_TKey) -> bool:
+        ...
+
+    @overload
+    def remove(self, item: System.Collections.Generic.KeyValuePair[Common_Util_BaseExtendedDictionary_TKey, Common_Util_BaseExtendedDictionary_TValue]) -> bool:
+        ...
+
+    def try_get_value(self, key: Common_Util_BaseExtendedDictionary_TKey, value: typing.Optional[Common_Util_BaseExtendedDictionary_TValue]) -> typing.Tuple[bool, Common_Util_BaseExtendedDictionary_TValue]:
+        ...
+
+

QuantConnect/Algorithm/Framework/Alphas/__init__.pyi

@@ -20,6 +20,8 @@ import QuantConnect.Securities
 import System
 import System.Collections.Generic
 
+QuantConnect_Algorithm_Framework_Alphas_AlphaModel = typing.Any
+
 
 class InsightType(IntEnum):
     """Specifies the type of insight"""
@@ -569,7 +571,7 @@ class INamedModel(metaclass=abc.ABCMeta):
         ...
 
 
-class AlphaModel(System.Object, QuantConnect.Algorithm.Framework.Alphas.IAlphaModel, QuantConnect.Algorithm.Framework.Alphas.INamedModel):
+class AlphaModel(QuantConnect.Python.BasePythonWrapper[QuantConnect_Algorithm_Framework_Alphas_AlphaModel], QuantConnect.Algorithm.Framework.Alphas.IAlphaModel, QuantConnect.Algorithm.Framework.Alphas.INamedModel):
     """Provides a base class for alpha models."""
 
     @property
@@ -940,19 +942,7 @@ class HistoricalReturnsAlphaModel(QuantConnect.Algorithm.Framework.Alphas.AlphaM
 class ConstantAlphaModel(QuantConnect.Algorithm.Framework.Alphas.AlphaModel):
     """Provides an implementation of IAlphaModel that always returns the same insight for each security"""
 
-    @overload
-    def __init__(self, type: QuantConnect.Algorithm.Framework.Alphas.InsightType, direction: QuantConnect.Algorithm.Framework.Alphas.InsightDirection, period: datetime.timedelta) -> None:
-        """
-        Initializes a new instance of the ConstantAlphaModel class
-        
-        :param type: The type of insight
-        :param direction: The direction of the insight
-        :param period: The period over which the insight with come to fruition
-        """
-        ...
-
-    @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] = None) -> None:
+    def __init__(self, type: QuantConnect.Algorithm.Framework.Alphas.InsightType, direction: QuantConnect.Algorithm.Framework.Alphas.InsightDirection, period: datetime.timedelta, magnitude: typing.Optional[float] = None, confidence: typing.Optional[float] = None, weight: typing.Optional[float] = None) -> None:
         """
         Initializes a new instance of the ConstantAlphaModel class
         

QuantConnect/Algorithm/Framework/Execution/__init__.pyi

@@ -13,9 +13,12 @@ import QuantConnect.Data.Market
 import QuantConnect.Data.UniverseSelection
 import QuantConnect.Indicators
 import QuantConnect.Orders
+import QuantConnect.Python
 import QuantConnect.Securities
 import System
 
+QuantConnect_Algorithm_Framework_Execution_ExecutionModel = typing.Any
+
 
 class IExecutionModel(QuantConnect.Algorithm.Framework.INotifiedSecurityChanges, metaclass=abc.ABCMeta):
     """Algorithm framework model that executes portfolio targets"""
@@ -41,7 +44,7 @@ class IExecutionModel(QuantConnect.Algorithm.Framework.INotifiedSecurityChanges,
         ...
 
 
-class ExecutionModel(System.Object, QuantConnect.Algorithm.Framework.Execution.IExecutionModel):
+class ExecutionModel(QuantConnect.Python.BasePythonWrapper[QuantConnect_Algorithm_Framework_Execution_ExecutionModel], QuantConnect.Algorithm.Framework.Execution.IExecutionModel):
     """Provides a base class for execution models"""
 
     @property

QuantConnect/Algorithm/Framework/Selection/__init__.pyi

@@ -13,11 +13,13 @@ import QuantConnect.Data.Fundamental
 import QuantConnect.Data.Market
 import QuantConnect.Data.UniverseSelection
 import QuantConnect.Interfaces
+import QuantConnect.Python
 import QuantConnect.Scheduling
 import QuantConnect.Securities
-import System
 import System.Collections.Generic
 
+QuantConnect_Algorithm_Framework_Selection_UniverseSelectionModel = typing.Any
+
 
 class IUniverseSelectionModel(metaclass=abc.ABCMeta):
     """Algorithm framework model that defines the universes to be used by an algorithm"""
@@ -36,9 +38,13 @@ class IUniverseSelectionModel(metaclass=abc.ABCMeta):
         ...
 
 
-class UniverseSelectionModel(System.Object, QuantConnect.Algorithm.Framework.Selection.IUniverseSelectionModel):
+class UniverseSelectionModel(QuantConnect.Python.BasePythonWrapper[QuantConnect_Algorithm_Framework_Selection_UniverseSelectionModel], QuantConnect.Algorithm.Framework.Selection.IUniverseSelectionModel):
     """Provides a base class for universe selection models."""
 
+    def __init__(self) -> None:
+        """Initializes a new instance of the UniverseSelectionModel class."""
+        ...
+
     def create_universes(self, algorithm: QuantConnect.Algorithm.QCAlgorithm) -> typing.Iterable[QuantConnect.Data.UniverseSelection.Universe]:
         """
         Creates the universes for this algorithm. Called once after IAlgorithm.initialize

QuantConnect/Algorithm/__init__.pyi

@@ -4,6 +4,7 @@ import datetime
 import typing
 import warnings
 
+import Common.Util
 import QuantConnect
 import QuantConnect.Algorithm
 import QuantConnect.Algorithm.Framework.Alphas
@@ -1055,7 +1056,7 @@ class QCAlgorithm(System.MarshalByRefObject, QuantConnect.Interfaces.IAlgorithm)
     @property
     def securities(self) -> QuantConnect.Securities.SecurityManager:
         """
-        Security collection is an array of the security objects such as Equities and FOREX. Securities data
+        Security collection is an array of the security objects such as Equity and Forex. Securities data
         manages the properties of tradeable assets such as price, open and close time and holdings information.
         """
         ...
@@ -1065,7 +1066,7 @@ class QCAlgorithm(System.MarshalByRefObject, QuantConnect.Interfaces.IAlgorithm)
         ...
 
     @property
-    def active_securities(self) -> System.Collections.Generic.IReadOnlyDictionary[QuantConnect.Symbol, QuantConnect.Securities.Security]:
+    def active_securities(self) -> Common.Util.ReadOnlyExtendedDictionary[QuantConnect.Symbol, QuantConnect.Securities.Security]:
         """
         Read-only dictionary containing all active securities. An active security is
         a security that is currently selected by the universe or has holdings or open orders.
@@ -1377,7 +1378,7 @@ class QCAlgorithm(System.MarshalByRefObject, QuantConnect.Interfaces.IAlgorithm)
 
     @property
     def benchmark(self) -> QuantConnect.Benchmarks.IBenchmark:
-        """Benchmark"""
+        """The IBenchmark for the algorithm"""
         ...
 
     @property
@@ -1490,11 +1491,11 @@ class QCAlgorithm(System.MarshalByRefObject, QuantConnect.Interfaces.IAlgorithm)
         """
         Creates and adds a new Cfd security to the algorithm
         
-        :param ticker: The currency pair
+        :param ticker: The CFD ticker symbol
         :param resolution: The Resolution of market data, Tick, Second, Minute, Hour, or Daily. Default is Resolution.MINUTE
-        :param market: The cfd trading market, Market. Default value is null and looked up using BrokerageModel.DefaultMarkets in AddSecurity{T}
+        :param market: The cfd trading market, Market. Default value is null and looked up using IBrokerageModel.default_markets in AddSecurity{T}
         :param fill_forward: If true, returns the last available data even if none in that timeslice. Default is true
-        :param leverage: The requested leverage for this equity. Default is set by security_initializer
+        :param leverage: The requested leverage for this CFD. Default is set by security_initializer
         :returns: The new Cfd security.
         """
         ...
@@ -1516,27 +1517,17 @@ class QCAlgorithm(System.MarshalByRefObject, QuantConnect.Interfaces.IAlgorithm)
         ...
 
     def add_crypto(self, ticker: str, resolution: typing.Optional[QuantConnect.Resolution] = None, market: str = None, fill_forward: bool = True, leverage: float = ...) -> QuantConnect.Securities.Crypto.Crypto:
-        """
-        Creates and adds a new Crypto security to the algorithm
-        
-        :param ticker: The currency pair
-        :param resolution: The Resolution of market data, Tick, Second, Minute, Hour, or Daily. Default is Resolution.MINUTE
-        :param market: The cfd trading market, Market. Default value is null and looked up using BrokerageModel.DefaultMarkets in AddSecurity{T}
-        :param fill_forward: If true, returns the last available data even if none in that timeslice. Default is true
-        :param leverage: The requested leverage for this equity. Default is set by security_initializer
-        :returns: The new Crypto security.
-        """
         ...
 
     def add_crypto_future(self, ticker: str, resolution: typing.Optional[QuantConnect.Resolution] = None, market: str = None, fill_forward: bool = True, leverage: float = ...) -> QuantConnect.Securities.CryptoFuture.CryptoFuture:
         """
         Creates and adds a new CryptoFuture security to the algorithm
         
-        :param ticker: The currency pair
+        :param ticker: The crypto future ticker symbol
         :param resolution: The Resolution of market data, Tick, Second, Minute, Hour, or Daily. Default is Resolution.MINUTE
-        :param market: The cfd trading market, Market. Default value is null and looked up using BrokerageModel.DefaultMarkets in AddSecurity{T}
+        :param market: The The crypto future trading market, Market. Default value is null and looked up using IBrokerageModel.default_markets in AddSecurity{T}
         :param fill_forward: If true, returns the last available data even if none in that timeslice. Default is true
-        :param leverage: The requested leverage for this equity. Default is set by security_initializer
+        :param leverage: The requested leverage for this crypto future. Default is set by security_initializer
         :returns: The new CryptoFuture security.
         """
         ...
@@ -1684,29 +1675,14 @@ class QCAlgorithm(System.MarshalByRefObject, QuantConnect.Interfaces.IAlgorithm)
         
         :param ticker: The currency pair
         :param resolution: The Resolution of market data, Tick, Second, Minute, Hour, or Daily. Default is Resolution.MINUTE
-        :param market: The foreign exchange trading market, Market. Default value is null and looked up using BrokerageModel.DefaultMarkets in AddSecurity{T}
+        :param market: The foreign exchange trading market, Market. Default value is null and looked up using IBrokerageModel.default_markets in AddSecurity{T}
         :param fill_forward: If true, returns the last available data even if none in that timeslice. Default is true
-        :param leverage: The requested leverage for this equity. Default is set by security_initializer
+        :param leverage: The requested leverage for this forex security. Default is set by security_initializer
         :returns: The new Forex security.
         """
         ...
 
     def add_future(self, ticker: str, resolution: typing.Optional[QuantConnect.Resolution] = None, market: str = None, fill_forward: bool = True, leverage: float = ..., extended_market_hours: bool = False, data_mapping_mode: typing.Optional[QuantConnect.DataMappingMode] = None, data_normalization_mode: typing.Optional[QuantConnect.DataNormalizationMode] = None, contract_depth_offset: int = 0) -> QuantConnect.Securities.Future.Future:
-        """
-        Creates and adds a new Future security to the algorithm
-        
-        :param ticker: The future ticker
-        :param resolution: The Resolution of market data, Tick, Second, Minute, Hour, or Daily. Default is Resolution.MINUTE
-        :param market: The futures market, Market. Default is value null and looked up using BrokerageModel.DefaultMarkets in AddSecurity{T}
-        :param fill_forward: If true, returns the last available data even if none in that timeslice. Default is true
-        :param leverage: The requested leverage for this equity. Default is set by security_initializer
-        :param extended_market_hours: Use extended market hours data
-        :param data_mapping_mode: The contract mapping mode to use for the continuous future contract
-        :param data_normalization_mode: The price scaling mode to use for the continuous future contract
-        :param contract_depth_offset: The continuous future contract desired offset from the current front month.
-        For example, 0 (default) will use the front month, 1 will use the back month contract
-        :returns: The new Future security.
-        """
         ...
 
     def add_future_contract(self, symbol: typing.Union[QuantConnect.Symbol, str, QuantConnect.Data.Market.BaseContract], resolution: typing.Optional[QuantConnect.Resolution] = None, fill_forward: bool = True, leverage: float = ..., extended_market_hours: bool = False) -> QuantConnect.Securities.Future.Future:
@@ -1716,7 +1692,7 @@ class QCAlgorithm(System.MarshalByRefObject, QuantConnect.Interfaces.IAlgorithm)
         :param symbol: The futures contract symbol
         :param resolution: The Resolution of market data, Tick, Second, Minute, Hour, or Daily. Default is Resolution.MINUTE
         :param fill_forward: If true, returns the last available data even if none in that timeslice. Default is true
-        :param leverage: The requested leverage for this equity. Default is set by security_initializer
+        :param leverage: The requested leverage for this future. Default is set by security_initializer
         :param extended_market_hours: Use extended market hours data
         :returns: The new Future security.
         """
@@ -1757,15 +1733,6 @@ class QCAlgorithm(System.MarshalByRefObject, QuantConnect.Interfaces.IAlgorithm)
         ...
 
     def add_index(self, ticker: str, resolution: typing.Optional[QuantConnect.Resolution] = None, market: str = None, fill_forward: bool = True) -> QuantConnect.Securities.Index.Index:
-        """
-        Creates and adds a new Index security to the algorithm
-        
-        :param ticker: The currency pair
-        :param resolution: The Resolution of market data, Tick, Second, Minute, Hour, or Daily. Default is Resolution.MINUTE
-        :param market: The index trading market, Market. Default value is null and looked up using BrokerageModel.DefaultMarkets in AddSecurity{T}
-        :param fill_forward: If true, returns the last available data even if none in that timeslice. Default is true
-        :returns: The new Index security.
-        """
         ...
 
     @overload
@@ -1773,9 +1740,9 @@ class QCAlgorithm(System.MarshalByRefObject, QuantConnect.Interfaces.IAlgorithm)
         """
         Creates and adds index options to the algorithm.
         
-        :param underlying: The underlying ticker of the Index Option
+        :param underlying: The underlying ticker of the IndexOption
         :param resolution: Resolution of the index option contracts, i.e. the granularity of the data
-        :param market: The foreign exchange trading market, Market. Default value is null and looked up using BrokerageModel.DefaultMarkets in AddSecurity{T}
+        :param market: The foreign exchange trading market, Market. Default value is null and looked up using IBrokerageModel.default_markets in AddSecurity{T}
         :param fill_forward: If true, this will fill in missing data points with the previous data point
         :returns: Canonical Option security.
         """
@@ -1808,16 +1775,6 @@ class QCAlgorithm(System.MarshalByRefObject, QuantConnect.Interfaces.IAlgorithm)
 
     @overload
     def add_index_option(self, underlying: str, target_option: str, resolution: typing.Optional[QuantConnect.Resolution] = None, market: str = None, fill_forward: bool = True) -> QuantConnect.Securities.IndexOption.IndexOption:
-        """
-        Creates and adds index options to the algorithm.
-        
-        :param underlying: The underlying ticker of the Index Option
-        :param target_option: The target option ticker. This is useful when the option ticker does not match the underlying, e.g. SPX index and the SPXW weekly option. If null is provided will use underlying
-        :param resolution: Resolution of the index option contracts, i.e. the granularity of the data
-        :param market: The foreign exchange trading market, Market. Default value is null and looked up using BrokerageModel.DefaultMarkets in AddSecurity{T}
-        :param fill_forward: If true, this will fill in missing data points with the previous data point
-        :returns: Canonical Option security.
-        """
         ...
 
     def add_index_option_contract(self, symbol: typing.Union[QuantConnect.Symbol, str, QuantConnect.Data.Market.BaseContract], resolution: typing.Optional[QuantConnect.Resolution] = None, fill_forward: bool = True) -> QuantConnect.Securities.IndexOption.IndexOption:
@@ -1854,7 +1811,7 @@ class QCAlgorithm(System.MarshalByRefObject, QuantConnect.Interfaces.IAlgorithm)
         
         :param underlying: Underlying asset Symbol to use as the option's underlying
         :param resolution: The Resolution of market data, Tick, Second, Minute, Hour, or Daily. Default is Resolution.MINUTE
-        :param market: The option's market, Market. Default value is null, but will be resolved using BrokerageModel.DefaultMarkets in AddSecurity{T}
+        :param market: The option's market, Market. Default value is null, but will be resolved using IBrokerageModel.default_markets in AddSecurity{T}
         :param fill_forward: If true, data will be provided to the algorithm every Second, Minute, Hour, or Day, while the asset is open and depending on the Resolution this option was configured to use.
         :param leverage: The requested leverage for the
         :returns: The new option security instance.
@@ -1871,7 +1828,7 @@ class QCAlgorithm(System.MarshalByRefObject, QuantConnect.Interfaces.IAlgorithm)
         :param underlying: Underlying asset Symbol to use as the option's underlying
         :param target_option: The target option ticker. This is useful when the option ticker does not match the underlying, e.g. SPX index and the SPXW weekly option. If null is provided will use underlying
         :param resolution: The Resolution of market data, Tick, Second, Minute, Hour, or Daily. Default is Resolution.MINUTE
-        :param market: The option's market, Market. Default value is null, but will be resolved using BrokerageModel.DefaultMarkets in AddSecurity{T}
+        :param market: The option's market, Market. Default value is null, but will be resolved using IBrokerageModel.default_markets in AddSecurity{T}
         :param fill_forward: If true, data will be provided to the algorithm every Second, Minute, Hour, or Day, while the asset is open and depending on the Resolution this option was configured to use.
         :param leverage: The requested leverage for the
         :returns: The new option security instance.
@@ -1885,7 +1842,7 @@ class QCAlgorithm(System.MarshalByRefObject, QuantConnect.Interfaces.IAlgorithm)
         :param symbol: The option contract symbol
         :param resolution: The Resolution of market data, Tick, Second, Minute, Hour, or Daily. Default is Resolution.MINUTE
         :param fill_forward: If true, returns the last available data even if none in that timeslice. Default is true
-        :param leverage: The requested leverage for this equity. Default is set by security_initializer
+        :param leverage: The requested leverage for this option. Default is set by security_initializer
         :param extended_market_hours: Use extended market hours data
         :returns: The new Option security.
         """
@@ -3377,8 +3334,8 @@ class QCAlgorithm(System.MarshalByRefObject, QuantConnect.Interfaces.IAlgorithm)
 
     def framework_post_initialize(self) -> None:
         """
-        Called by setup handlers after Initialize and allows the algorithm a chance to organize
-        the data gather in the Initialize method
+        Called by setup handlers after initialize and allows the algorithm a chance to organize
+        the data gather in the initialize method
         """
         ...
 
@@ -3475,6 +3432,7 @@ class QCAlgorithm(System.MarshalByRefObject, QuantConnect.Interfaces.IAlgorithm)
         """
         ...
 
+    @overload
     def get_last_known_price(self, security: QuantConnect.Securities.Security) -> QuantConnect.Data.BaseData:
         """
         Get the last known price using the history provider.
@@ -3486,7 +3444,21 @@ class QCAlgorithm(System.MarshalByRefObject, QuantConnect.Interfaces.IAlgorithm)
         :param security: Security object for which to retrieve historical data
         :returns: A single BaseData object with the last known price.
         """
-        warnings.warn("This method is obsolete please use 'GetLastKnownPrices' which will return the last data point for each type associated with the requested security", DeprecationWarning)
+        ...
+
+    @overload
+    def get_last_known_price(self, symbol: typing.Union[QuantConnect.Symbol, str, QuantConnect.Data.Market.BaseContract]) -> QuantConnect.Data.BaseData:
+        """
+        Get the last known price using the history provider.
+        Useful for seeding securities with the correct price
+        
+        
+        This method is obsolete please use 'GetLastKnownPrices' which will return the last data point for each type associated with the requested security
+        
+        :param symbol: Symbol for which to retrieve historical data
+        :returns: A single BaseData object with the last known price.
+        """
+        ...
 
     @overload
     def get_last_known_prices(self, security: QuantConnect.Securities.Security) -> typing.Iterable[QuantConnect.Data.BaseData]:
@@ -3501,13 +3473,33 @@ class QCAlgorithm(System.MarshalByRefObject, QuantConnect.Interfaces.IAlgorithm)
     @overload
     def get_last_known_prices(self, symbol: typing.Union[QuantConnect.Symbol, str, QuantConnect.Data.Market.BaseContract]) -> typing.Iterable[QuantConnect.Data.BaseData]:
         """
-        Yields data to warmup a security for all it's subscribed data types
+        Yields data to warm up a security for all its subscribed data types
         
         :param symbol: The symbol we want to get seed data for
         :returns: Securities historical data.
         """
         ...
 
+    @overload
+    def get_last_known_prices(self, securities: typing.List[QuantConnect.Securities.Security]) -> QuantConnect.Data.Market.DataDictionary[typing.Iterable[QuantConnect.Data.BaseData]]:
+        """
+        Yields data to warm up multiple securities for all their subscribed data types
+        
+        :param securities: The securities we want to get seed data for
+        :returns: Securities historical data.
+        """
+        ...
+
+    @overload
+    def get_last_known_prices(self, symbols: typing.List[QuantConnect.Symbol]) -> QuantConnect.Data.Market.DataDictionary[typing.Iterable[QuantConnect.Data.BaseData]]:
+        """
+        Yields data to warm up multiple securities for all their subscribed data types
+        
+        :param symbols: The symbols we want to get seed data for
+        :returns: Securities historical data.
+        """
+        ...
+
     def get_locked(self) -> bool:
         """Gets whether or not this algorithm has been locked and fully initialized"""
         ...
@@ -3548,7 +3540,7 @@ class QCAlgorithm(System.MarshalByRefObject, QuantConnect.Interfaces.IAlgorithm)
         """
         ...
 
-    def get_parameters(self) -> System.Collections.Generic.IReadOnlyDictionary[str, str]:
+    def get_parameters(self) -> Common.Util.ReadOnlyExtendedDictionary[str, str]:
         """Gets a read-only dictionary with all current parameters"""
         ...
 
@@ -4412,7 +4404,11 @@ class QCAlgorithm(System.MarshalByRefObject, QuantConnect.Interfaces.IAlgorithm)
         ...
 
     def on_brokerage_message(self, message_event: QuantConnect.Brokerages.BrokerageMessageEvent) -> None:
-        """Brokerage message event handler. This method is called for all types of brokerage messages."""
+        """
+        Brokerage message event handler. This method is called for all types of brokerage messages.
+        
+        :param message_event: The brokerage message event instance containing the message details.
+        """
         ...
 
     def on_brokerage_reconnect(self) -> None:
@@ -4475,7 +4471,7 @@ class QCAlgorithm(System.MarshalByRefObject, QuantConnect.Interfaces.IAlgorithm)
         """
         Used to send data updates to algorithm framework models
         
-        :param slice: The current data slice
+        :param slice: The current data Slice
         """
         ...
 
@@ -5242,14 +5238,14 @@ class QCAlgorithm(System.MarshalByRefObject, QuantConnect.Interfaces.IAlgorithm)
         Sets the benchmark used for computing statistics of the algorithm to the specified symbol
         
         :param symbol: symbol to use as the benchmark
-        :param security_type: Is the symbol an equity, forex, base, etc. Default SecurityType.Equity
+        :param security_type: Is the symbol an equity, forex, base, etc. Default SecurityType.EQUITY
         """
         ...
 
     @overload
     def set_benchmark(self, ticker: str) -> None:
         """
-        Sets the benchmark used for computing statistics of the algorithm to the specified ticker, defaulting to SecurityType.Equity
+        Sets the benchmark used for computing statistics of the algorithm to the specified ticker, defaulting to SecurityType.EQUITY
         if the ticker doesn't exist in the algorithm
         
         :param ticker: Ticker to use as the benchmark
@@ -5636,7 +5632,7 @@ class QCAlgorithm(System.MarshalByRefObject, QuantConnect.Interfaces.IAlgorithm)
         """
         Set the start date for the backtest
         
-        :param start: Datetime Start date for backtest
+        :param start: The start date for the backtest
         """
         ...
 
@@ -6708,18 +6704,18 @@ class DollarVolumeUniverseDefinitions(System.Object):
 
     def top(self, count: int, universe_settings: QuantConnect.Data.UniverseSelection.UniverseSettings = None) -> QuantConnect.Data.UniverseSelection.Universe:
         """
-        Creates a new coarse universe that contains the top count of stocks
+        Creates a new coarse Universe that contains the top count of stocks
         by daily dollar volume
         
         
-        This method is deprecated. Use method `Universe.DollarVolume.Top(...)` instead
+        This method is deprecated. Use method `Universe.Top(...)` instead
         
         :param count: The number of stock to select
         :param universe_settings: The settings for stocks added by this universe.
         Defaults to QCAlgorithm.universe_settings
         :returns: A new coarse universe for the top count of stocks by dollar volume.
         """
-        warnings.warn("This method is deprecated. Use method `Universe.DollarVolume.Top(...)` instead", DeprecationWarning)
+        warnings.warn("This method is deprecated. Use method `Universe.Top(...)` instead", DeprecationWarning)
 
 
 class UniverseDefinitions(System.Object):