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

QuantConnect/AlgorithmFactory/Python/Wrappers/__init__.pyi

@@ -3,6 +3,7 @@ from enum import IntEnum
 import datetime
 import typing
 
+import Common.Util
 import QuantConnect
 import QuantConnect.Algorithm
 import QuantConnect.Algorithm.Framework.Alphas
@@ -470,16 +471,36 @@ class AlgorithmPythonWrapper(QuantConnect.Python.BasePythonWrapper[QuantConnect.
         """
         ...
 
-    def get_last_known_price(self, security: QuantConnect.Securities.Security) -> QuantConnect.Data.BaseData:
+    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
         
-        :param security: Security object for which to retrieve historical data
+        :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, 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
+        
+        :param symbol: Symbol for which to retrieve historical data
+        :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"""
         ...
@@ -520,7 +541,7 @@ class AlgorithmPythonWrapper(QuantConnect.Python.BasePythonWrapper[QuantConnect.
         """
         ...
 
-    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"""
         ...
 

QuantConnect/Api/__init__.pyi

@@ -2,6 +2,7 @@ from typing import overload
 from enum import IntEnum
 import datetime
 import typing
+import warnings
 
 import QuantConnect
 import QuantConnect.Algorithm.Framework.Alphas
@@ -28,18 +29,24 @@ class ApiConnection(System.Object):
 
     @property
     def client(self) -> typing.Any:
-        """Authorized client to use for requests."""
-        ...
+        """
+        Authorized client to use for requests.
+        
+        
+        RestSharp is deprecated and will be removed in a future release. Please use the SetClient method or the request methods that take an HttpRequestMessage
+        """
+        warnings.warn("RestSharp is deprecated and will be removed in a future release. Please use the SetClient method or the request methods that take an HttpRequestMessage", DeprecationWarning)
 
     @client.setter
     def client(self, value: typing.Any) -> None:
-        ...
+        warnings.warn("RestSharp is deprecated and will be removed in a future release. Please use the SetClient method or the request methods that take an HttpRequestMessage", DeprecationWarning)
 
     @property
     def connected(self) -> bool:
         """Return true if connected successfully."""
         ...
 
+    @overload
     def __init__(self, user_id: int, token: str) -> None:
         """
         Create a new Api Connection Class.
@@ -49,6 +56,29 @@ class ApiConnection(System.Object):
         """
         ...
 
+    @overload
+    def __init__(self, user_id: int, token: str, base_url: str = None, default_headers: System.Collections.Generic.Dictionary[str, str] = None, timeout: int = 0) -> None:
+        """
+        Create a new Api Connection Class.
+        
+        :param user_id: User Id number from QuantConnect.com account. Found at www.quantconnect.com/account
+        :param token: Access token for the QuantConnect account. Found at www.quantconnect.com/account
+        :param base_url: The client's base address
+        :param default_headers: Default headers for the client
+        :param timeout: The client timeout in seconds
+        """
+        ...
+
+    def set_client(self, base_url: str, default_headers: System.Collections.Generic.Dictionary[str, str] = None, timeout: int = 0) -> None:
+        """
+        Overrides the current client
+        
+        :param base_url: The client's base address
+        :param default_headers: Default headers for the client
+        :param timeout: The client timeout in seconds
+        """
+        ...
+
 
 class StringRepresentation(System.Object):
     """Class to return the string representation of an API response class"""
@@ -3723,10 +3753,13 @@ class NodeType(IntEnum):
     """
 
     BACKTEST = 0
+    """A node for running backtests (0)"""
 
     RESEARCH = 1
+    """A node for running research (1)"""
 
     LIVE = 2
+    """A node for live trading (2)"""
 
 
 class SKU(System.Object):

QuantConnect/Brokerages/__init__.pyi

@@ -2290,6 +2290,74 @@ class DefaultBrokerageModel(System.Object, QuantConnect.Brokerages.IBrokerageMod
         ...
 
 
+class dYdXBrokerageModel(QuantConnect.Brokerages.DefaultBrokerageModel):
+    """This class has no documentation."""
+
+    @property
+    def default_markets(self) -> System.Collections.Generic.IReadOnlyDictionary[QuantConnect.SecurityType, str]:
+        """Gets a map of the default markets to be used for each security type"""
+        ...
+
+    def __init__(self, account_type: QuantConnect.AccountType = ...) -> None:
+        """
+        Initializes a new instance of the dYdXBrokerageModel class
+        
+        :param account_type: The type of account to be modeled, defaults to AccountType.MARGIN
+        """
+        ...
+
+    def can_submit_order(self, security: QuantConnect.Securities.Security, order: QuantConnect.Orders.Order, message: typing.Optional[QuantConnect.Brokerages.BrokerageMessageEvent]) -> typing.Tuple[bool, QuantConnect.Brokerages.BrokerageMessageEvent]:
+        """
+        Returns true if the brokerage could accept this order. This takes into account
+        order type, security type, and order size limits.
+        
+        :param security: The security of the order
+        :param order: The order to be processed
+        :param message: If this function returns false, a brokerage message detailing why the order may not be submitted
+        :returns: True if the brokerage could process the order, false otherwise.
+        """
+        ...
+
+    def can_update_order(self, security: QuantConnect.Securities.Security, order: QuantConnect.Orders.Order, request: QuantConnect.Orders.UpdateOrderRequest, message: typing.Optional[QuantConnect.Brokerages.BrokerageMessageEvent]) -> typing.Tuple[bool, QuantConnect.Brokerages.BrokerageMessageEvent]:
+        """
+        Returns true if the brokerage could accept this order update. This takes into account
+        order type, security type, and order size limits. dYdX can only update inverse, linear, and option orders
+        
+        :param security: The security of the order
+        :param order: The order to be updated
+        :param request: The requested update to be made to the order
+        :param message: If this function returns false, a brokerage message detailing why the order may not be updated
+        :returns: True if the brokerage could update the order, false otherwise.
+        """
+        ...
+
+    def get_benchmark(self, securities: QuantConnect.Securities.SecurityManager) -> QuantConnect.Benchmarks.IBenchmark:
+        """
+        Get the benchmark for this model
+        
+        :param securities: SecurityService to create the security with if needed
+        :returns: The benchmark for this brokerage.
+        """
+        ...
+
+    def get_fee_model(self, security: QuantConnect.Securities.Security) -> QuantConnect.Orders.Fees.IFeeModel:
+        """
+        Provides dYdX fee model
+        
+        :param security: 
+        """
+        ...
+
+    def get_margin_interest_rate_model(self, security: QuantConnect.Securities.Security) -> QuantConnect.Securities.IMarginInterestRateModel:
+        """
+        Gets a new margin interest rate model for the security
+        
+        :param security: The security to get a margin interest rate model for
+        :returns: The margin interest rate model for this brokerage.
+        """
+        ...
+
+
 class BinanceBrokerageModel(QuantConnect.Brokerages.DefaultBrokerageModel):
     """Provides Binance specific properties"""
 
@@ -2624,6 +2692,9 @@ class BrokerageName(IntEnum):
     INTERACTIVE_BROKERS_FIX = 33
     """Transaction and submit/execution rules will use interactive brokers Fix models"""
 
+    D_YD_X = 34
+    """Transaction and submit/execution rules will use dYdX models"""
+
 
 class BrokerageModel(System.Object):
     """Provides factory method for creating an IBrokerageModel from the BrokerageName enum"""

QuantConnect/Data/Market/__init__.pyi

@@ -5,6 +5,7 @@ import datetime
 import typing
 import warnings
 
+import Common.Util
 import QuantConnect
 import QuantConnect.Data
 import QuantConnect.Data.Market
@@ -2672,7 +2673,7 @@ class SessionBar(QuantConnect.Data.Market.TradeBar):
         ...
 
 
-class DataDictionary(typing.Generic[QuantConnect_Data_Market_DataDictionary_T], QuantConnect.ExtendedDictionary[QuantConnect.Symbol, QuantConnect_Data_Market_DataDictionary_T], System.Collections.Generic.IDictionary[QuantConnect.Symbol, QuantConnect_Data_Market_DataDictionary_T], typing.Iterable[System.Collections.Generic.KeyValuePair[QuantConnect.Symbol, QuantConnect_Data_Market_DataDictionary_T]]):
+class DataDictionary(typing.Generic[QuantConnect_Data_Market_DataDictionary_T], Common.Util.BaseExtendedDictionary[QuantConnect.Symbol, QuantConnect_Data_Market_DataDictionary_T], typing.Iterable[System.Collections.Generic.KeyValuePair[QuantConnect.Symbol, QuantConnect_Data_Market_DataDictionary_T]]):
     """Provides a base class for types holding base data instances keyed by symbol"""
 
     @property
@@ -2684,20 +2685,10 @@ class DataDictionary(typing.Generic[QuantConnect_Data_Market_DataDictionary_T],
     def time(self, value: datetime.datetime) -> None:
         ...
 
-    @property
-    def count(self) -> int:
-        """Gets the number of elements contained in the System.Collections.Generic.ICollection`1."""
-        ...
-
-    @property
-    def is_read_only(self) -> bool:
-        """Gets a value indicating whether the System.Collections.Generic.ICollection`1 is read-only."""
-        ...
-
     @property
     def get_keys(self) -> typing.Iterable[QuantConnect.Symbol]:
         """
-        Gets an System.Collections.Generic.ICollection`1 containing the Symbol objects of the System.Collections.Generic.IDictionary`2.
+        Gets a collection containing the keys in the dictionary
         
         
         This codeEntityType is protected.
@@ -2707,40 +2698,15 @@ class DataDictionary(typing.Generic[QuantConnect_Data_Market_DataDictionary_T],
     @property
     def get_values(self) -> typing.Iterable[QuantConnect_Data_Market_DataDictionary_T]:
         """
-        Gets an System.Collections.Generic.ICollection`1 containing the values in the System.Collections.Generic.IDictionary`2.
+        Gets a collection containing the values in the dictionary
         
         
         This codeEntityType is protected.
         """
         ...
 
-    def __contains__(self, key: typing.Union[QuantConnect.Symbol, str, QuantConnect.Data.Market.BaseContract]) -> bool:
-        """
-        Determines whether the System.Collections.Generic.IDictionary{TKey, TValue} contains an element with the specified key.
-        
-        :param key: The key to locate in the System.Collections.Generic.IDictionary{TKey, TValue}.
-        :returns: true if the System.Collections.Generic.IDictionary{TKey, TValue} contains an element with the key; otherwise, false.
-        """
-        ...
-
-    @overload
     def __getitem__(self, symbol: typing.Union[QuantConnect.Symbol, str, QuantConnect.Data.Market.BaseContract]) -> QuantConnect_Data_Market_DataDictionary_T:
-        """
-        Gets or sets the element with the specified key.
-        
-        :param symbol: The key of the element to get or set.
-        :returns: The element with the specified key.
-        """
-        ...
-
-    @overload
-    def __getitem__(self, key: typing.Union[QuantConnect.Symbol, str, QuantConnect.Data.Market.BaseContract]) -> QuantConnect_Data_Market_DataDictionary_T:
-        """
-        Indexer method for the base dictioanry to access the objects by their symbol.
-        
-        :param key: Key object indexer
-        :returns: Object of t_value.
-        """
+        """Gets or sets the element with the specified key."""
         ...
 
     @overload
@@ -2771,107 +2737,38 @@ class DataDictionary(typing.Generic[QuantConnect_Data_Market_DataDictionary_T],
     def __iter__(self) -> typing.Iterator[System.Collections.Generic.KeyValuePair[QuantConnect.Symbol, QuantConnect_Data_Market_DataDictionary_T]]:
         ...
 
-    def __len__(self) -> int:
-        ...
-
-    @overload
     def __setitem__(self, symbol: typing.Union[QuantConnect.Symbol, str, QuantConnect.Data.Market.BaseContract], value: QuantConnect_Data_Market_DataDictionary_T) -> None:
-        """
-        Gets or sets the element with the specified key.
-        
-        :param symbol: The key of the element to get or set.
-        :returns: The element with the specified key.
-        """
+        """Gets or sets the element with the specified key."""
         ...
 
     @overload
-    def __setitem__(self, key: typing.Union[QuantConnect.Symbol, str, QuantConnect.Data.Market.BaseContract], value: QuantConnect_Data_Market_DataDictionary_T) -> None:
+    def add(self, key: typing.Union[QuantConnect.Symbol, str, QuantConnect.Data.Market.BaseContract], value: QuantConnect_Data_Market_DataDictionary_T) -> None:
         """
-        Indexer method for the base dictioanry to access the objects by their symbol.
+        Adds an element with the provided key and value to the dictionary
         
-        :param key: Key object indexer
-        :returns: Object of t_value.
+        :param key: The key of the element to add
+        :param value: The value of the element to add
         """
         ...
 
     @overload
     def add(self, item: System.Collections.Generic.KeyValuePair[QuantConnect.Symbol, QuantConnect_Data_Market_DataDictionary_T]) -> None:
         """
-        Adds an item to the System.Collections.Generic.ICollection`1.
+        Adds an element with the provided key-value pair to the dictionary
         
-        :param item: The object to add to the System.Collections.Generic.ICollection`1.
-        """
-        ...
-
-    @overload
-    def add(self, key: typing.Union[QuantConnect.Symbol, str, QuantConnect.Data.Market.BaseContract], value: QuantConnect_Data_Market_DataDictionary_T) -> None:
-        """
-        Adds an element with the provided key and value to the System.Collections.Generic.IDictionary{TKey, TValue}.
-        
-        :param key: The object to use as the key of the element to add.
-        :param value: The object to use as the value of the element to add.
+        :param item: The key-value pair to add
         """
         ...
 
     def clear(self) -> None:
-        """Removes all items from the System.Collections.Generic.ICollection`1."""
-        ...
-
-    def contains(self, item: System.Collections.Generic.KeyValuePair[QuantConnect.Symbol, QuantConnect_Data_Market_DataDictionary_T]) -> bool:
-        """
-        Determines whether the System.Collections.Generic.ICollection`1 contains a specific value.
-        
-        :param item: The object to locate in the System.Collections.Generic.ICollection`1.
-        :returns: true if item is found in the System.Collections.Generic.ICollection`1; otherwise, false.
-        """
-        ...
-
-    def contains_key(self, key: typing.Union[QuantConnect.Symbol, str, QuantConnect.Data.Market.BaseContract]) -> bool:
-        """
-        Determines whether the System.Collections.Generic.IDictionary{TKey, TValue} contains an element with the specified key.
-        
-        :param key: The key to locate in the System.Collections.Generic.IDictionary{TKey, TValue}.
-        :returns: true if the System.Collections.Generic.IDictionary{TKey, TValue} contains an element with the key; otherwise, false.
-        """
-        ...
-
-    def copy_to(self, array: typing.List[System.Collections.Generic.KeyValuePair[QuantConnect.Symbol, QuantConnect_Data_Market_DataDictionary_T]], array_index: int) -> None:
-        """
-        Copies the elements of the System.Collections.Generic.ICollection`1 to an System.Array, starting at a particular System.Array index.
-        
-        :param array: The one-dimensional System.Array that is the destination of the elements copied from System.Collections.Generic.ICollection`1. The System.Array must have zero-based indexing.
-        :param array_index: The zero-based index in array at which copying begins.
-        """
-        ...
-
-    @overload
-    def get(self, key: typing.Union[QuantConnect.Symbol, str, QuantConnect.Data.Market.BaseContract]) -> QuantConnect_Data_Market_DataDictionary_T:
-        """
-        Returns the value for the specified key if key is in dictionary.
-        
-        :param key: key to be searched in the dictionary
-        :returns: The value for the specified key if key is in dictionary.
-        None if the key is not found and value is not specified.
-        """
-        ...
-
-    @overload
-    def get(self, key: typing.Union[QuantConnect.Symbol, str, QuantConnect.Data.Market.BaseContract], value: QuantConnect_Data_Market_DataDictionary_T) -> QuantConnect_Data_Market_DataDictionary_T:
-        """
-        Returns the value for the specified key if key is in dictionary.
-        
-        :param key: key to be searched in the dictionary
-        :param value: Value to be returned if the key is not found. The default value is null.
-        :returns: The value for the specified key if key is in dictionary.
-        value if the key is not found and value is specified.
-        """
+        """Removes all items from the dictionary"""
         ...
 
     def get_enumerator(self) -> System.Collections.Generic.IEnumerator[System.Collections.Generic.KeyValuePair[QuantConnect.Symbol, QuantConnect_Data_Market_DataDictionary_T]]:
         """
-        Returns an enumerator that iterates through the collection.
+        Returns an enumerator that iterates through the dictionary
         
-        :returns: A System.Collections.Generic.IEnumerator`1 that can be used to iterate through the collection.
+        :returns: An enumerator for the dictionary.
         """
         ...
 
@@ -2884,87 +2781,26 @@ class DataDictionary(typing.Generic[QuantConnect_Data_Market_DataDictionary_T],
         ...
 
     def get_value(self, key: typing.Union[QuantConnect.Symbol, str, QuantConnect.Data.Market.BaseContract]) -> QuantConnect_Data_Market_DataDictionary_T:
-        """
-        Gets the value associated with the specified key.
-        
-        :param key: The key whose value to get.
-        :returns: The value associated with the specified key, if the key is found; otherwise, the default value for the type of the t parameter.
-        """
-        ...
-
-    @overload
-    def pop(self, key: typing.Union[QuantConnect.Symbol, str, QuantConnect.Data.Market.BaseContract]) -> QuantConnect_Data_Market_DataDictionary_T:
-        """
-        Removes and returns an element from a dictionary having the given key.
-        
-        :param key: Key which is to be searched for removal
-        :returns: If key is found - removed/popped element from the dictionary
-        If key is not found - KeyError exception is raised.
-        """
-        ...
-
-    @overload
-    def pop(self, key: typing.Union[QuantConnect.Symbol, str, QuantConnect.Data.Market.BaseContract], default_value: QuantConnect_Data_Market_DataDictionary_T) -> QuantConnect_Data_Market_DataDictionary_T:
-        """
-        Removes and returns an element from a dictionary having the given key.
-        
-        :param key: Key which is to be searched for removal
-        :param default_value: Value which is to be returned when the key is not in the dictionary
-        :returns: If key is found - removed/popped element from the dictionary
-        If key is not found - value specified as the second argument(default).
-        """
-        ...
-
-    @overload
-    def remove(self, item: System.Collections.Generic.KeyValuePair[QuantConnect.Symbol, QuantConnect_Data_Market_DataDictionary_T]) -> bool:
-        """
-        Removes the first occurrence of a specific object from the System.Collections.Generic.ICollection`1.
-        
-        :param item: The object to remove from the System.Collections.Generic.ICollection`1.
-        :returns: true if item was successfully removed from the System.Collections.Generic.ICollection`1; otherwise, false. This method also returns false if item is not found in the original System.Collections.Generic.ICollection`1.
-        """
+        """Gets the value associated with the specified key."""
         ...
 
     @overload
     def remove(self, key: typing.Union[QuantConnect.Symbol, str, QuantConnect.Data.Market.BaseContract]) -> bool:
         """
-        Removes the element with the specified key from the System.Collections.Generic.IDictionary{TKey, TValue}.
+        Removes the value with the specified key
         
-        :param key: The key of the element to remove.
-        :returns: true if the element is successfully removed; otherwise, false.  This method also returns false if key was not found in the original System.Collections.Generic.IDictionary{TKey, TValue}.
+        :param key: The key of the element to remove
+        :returns: true if the element was successfully found and removed; otherwise, false.
         """
         ...
 
     @overload
-    def setdefault(self, key: typing.Union[QuantConnect.Symbol, str, QuantConnect.Data.Market.BaseContract]) -> QuantConnect_Data_Market_DataDictionary_T:
-        """
-        Returns the value of a key (if the key is in dictionary). If not, it inserts key with a value to the dictionary.
-        
-        :param key: Key with null/None value is inserted to the dictionary if key is not in the dictionary.
-        :returns: The value of the key if it is in the dictionary
-        None if key is not in the dictionary.
-        """
-        ...
-
-    @overload
-    def setdefault(self, key: typing.Union[QuantConnect.Symbol, str, QuantConnect.Data.Market.BaseContract], default_value: QuantConnect_Data_Market_DataDictionary_T) -> QuantConnect_Data_Market_DataDictionary_T:
-        """
-        Returns the value of a key (if the key is in dictionary). If not, it inserts key with a value to the dictionary.
-        
-        :param key: Key with a value default_value is inserted to the dictionary if key is not in the dictionary.
-        :param default_value: Default value
-        :returns: The value of the key if it is in the dictionary
-        default_value if key is not in the dictionary and default_value is specified.
-        """
-        ...
-
-    def try_get_value(self, key: typing.Union[QuantConnect.Symbol, str, QuantConnect.Data.Market.BaseContract], value: typing.Optional[QuantConnect_Data_Market_DataDictionary_T]) -> typing.Tuple[bool, QuantConnect_Data_Market_DataDictionary_T]:
+    def remove(self, item: System.Collections.Generic.KeyValuePair[QuantConnect.Symbol, QuantConnect_Data_Market_DataDictionary_T]) -> bool:
         """
-        Gets the value associated with the specified key.
+        Removes the first occurrence of a specific object from the dictionary
         
-        :param key: The key whose value to get.
-        :param value: When this method returns, the value associated with the specified key, if the key is found; otherwise, the default value for the type of the value parameter. This parameter is passed uninitialized.
-        :returns: true if the object that implements System.Collections.Generic.IDictionary{TKey, TValue} contains an element with the specified key; otherwise, false.
+        :param item: The key-value pair to remove
+        :returns: true if the key-value pair was successfully removed; otherwise, false.
         """
         ...
 

QuantConnect/Data/__init__.pyi

@@ -940,7 +940,7 @@ class Slice(QuantConnect.ExtendedDictionary[QuantConnect.Symbol, typing.Any], ty
     """Provides a data structure for all of an algorithm's data at a single time step"""
 
     @property
-    def all_data(self) -> typing.List[QuantConnect.Data.BaseData]:
+    def all_data(self) -> typing.Iterable[QuantConnect.Data.BaseData]:
         """All the data hold in this slice"""
         ...
 
@@ -2779,6 +2779,11 @@ class SubscriptionDataConfigExtensions(System.Object):
     for a given set of SubscriptionDataConfig
     """
 
+    @staticmethod
+    def can_be_delisted(config: QuantConnect.Data.SubscriptionDataConfig) -> bool:
+        """True if this configuration is associated with an asset which can have delisting events"""
+        ...
+
     @staticmethod
     def data_normalization_mode(subscription_data_configs: typing.List[QuantConnect.Data.SubscriptionDataConfig]) -> QuantConnect.DataNormalizationMode:
         """