{

private readonly Dictionary<IntPtr, PythonIndicator> _pythonIndicators = new Dictionary<IntPtr, PythonIndicator>();

/// <summary>

/// PandasConverter for this Algorithm

/// </summary>

public PandasConverter PandasConverter { get; private set; }

/// <summary>

/// Sets pandas converter

/// </summary>

public void SetPandasConverter()

{

PandasConverter = new PandasConverter();

}

/// <summary>

/// AddData a new user defined data source, requiring only the minimum config options.

/// The data is added with a default time zone of NewYork (Eastern Daylight Savings Time).

/// This method is meant for custom data types that require a ticker, but have no underlying Symbol.

/// Examples of data sources that meet this criteria are U.S. Treasury Yield Curve Rates and Trading Economics data

/// </summary>

/// <param name="type">Data source type</param>

/// <param name="ticker">Key/Ticker for data</param>

/// <param name="resolution">Resolution of the data</param>

/// <returns>The new <see cref="Security"/></returns>

[DocumentationAttribute(AddingData)]

public Security AddData(PyObject type, string ticker, Resolution? resolution = null)

{

return AddData(type, ticker, resolution, null, false, 1m);

}

/// <summary>

/// AddData a new user defined data source, requiring only the minimum config options.

/// The data is added with a default time zone of NewYork (Eastern Daylight Savings Time).

/// This adds a Symbol to the `Underlying` property in the custom data Symbol object.

/// Use this method when adding custom data with a ticker from the past, such as "AOL"

/// before it became "TWX", or if you need to filter using custom data and place trades on the

/// Symbol associated with the custom data.

/// </summary>

/// <param name="type">Data source type</param>

/// <param name="underlying">The underlying symbol for the custom data</param>

/// <param name="resolution">Resolution of the data</param>

/// <returns>The new <see cref="Security"/></returns>

/// <remarks>

/// We include three optional unused object parameters so that pythonnet chooses the intended method

/// correctly. Previously, calling the overloaded method that accepts a string would instead call this method.

/// Adding the three unused parameters makes it choose the correct method when using a string or Symbol. This is

/// due to pythonnet's method precedence, as viewable here: https://github.com/QuantConnect/pythonnet/blob/9e29755c54e6008cb016e3dd9d75fbd8cd19fcf7/src/runtime/methodbinder.cs#L215

/// </remarks>

[DocumentationAttribute(AddingData)]

public Security AddData(PyObject type, Symbol underlying, Resolution? resolution = null)

{

return AddData(type, underlying, resolution, null, false, 1m);

}

/// <summary>

/// AddData a new user defined data source, requiring only the minimum config options.

/// This method is meant for custom data types that require a ticker, but have no underlying Symbol.

/// Examples of data sources that meet this criteria are U.S. Treasury Yield Curve Rates and Trading Economics data

/// </summary>

/// <param name="type">Data source type</param>

/// <param name="ticker">Key/Ticker for data</param>

/// <param name="resolution">Resolution of the Data Required</param>

/// <param name="timeZone">Specifies the time zone of the raw data</param>

/// <param name="fillForward">When no data available on a tradebar, return the last data that was generated</param>

/// <param name="leverage">Custom leverage per security</param>

/// <returns>The new <see cref="Security"/></returns>

[DocumentationAttribute(AddingData)]

public Security AddData(PyObject type, string ticker, Resolution? resolution, DateTimeZone timeZone, bool fillForward = false, decimal leverage = 1.0m)

{

return AddData(type.CreateType(), ticker, resolution, timeZone, fillForward, leverage);

}

/// <summary>

/// AddData a new user defined data source, requiring only the minimum config options.

/// This adds a Symbol to the `Underlying` property in the custom data Symbol object.

/// Use this method when adding custom data with a ticker from the past, such as "AOL"

/// before it became "TWX", or if you need to filter using custom data and place trades on the

/// Symbol associated with the custom data.

/// </summary>

/// <param name="type">Data source type</param>

/// <param name="underlying">The underlying symbol for the custom data</param>

/// <param name="resolution">Resolution of the Data Required</param>

/// <param name="timeZone">Specifies the time zone of the raw data</param>

/// <param name="fillForward">When no data available on a tradebar, return the last data that was generated</param>

/// <param name="leverage">Custom leverage per security</param>

/// <returns>The new <see cref="Security"/></returns>

/// <remarks>

/// We include three optional unused object parameters so that pythonnet chooses the intended method

/// correctly. Previously, calling the overloaded method that accepts a string would instead call this method.

/// Adding the three unused parameters makes it choose the correct method when using a string or Symbol. This is

/// due to pythonnet's method precedence, as viewable here: https://github.com/QuantConnect/pythonnet/blob/9e29755c54e6008cb016e3dd9d75fbd8cd19fcf7/src/runtime/methodbinder.cs#L215

/// </remarks>

[DocumentationAttribute(AddingData)]

public Security AddData(PyObject type, Symbol underlying, Resolution? resolution, DateTimeZone timeZone, bool fillForward = false, decimal leverage = 1.0m)

{

return AddData(type.CreateType(), underlying, resolution, timeZone, fillForward, leverage);

}

/// <summary>

/// AddData a new user defined data source, requiring only the minimum config options.

/// This method is meant for custom data types that require a ticker, but have no underlying Symbol.

/// Examples of data sources that meet this criteria are U.S. Treasury Yield Curve Rates and Trading Economics data

/// </summary>

/// <param name="dataType">Data source type</param>

/// <param name="ticker">Key/Ticker for data</param>

/// <param name="resolution">Resolution of the Data Required</param>

/// <param name="timeZone">Specifies the time zone of the raw data</param>

/// <param name="fillForward">When no data available on a tradebar, return the last data that was generated</param>

/// <param name="leverage">Custom leverage per security</param>

/// <returns>The new <see cref="Security"/></returns>

[DocumentationAttribute(AddingData)]

public Security AddData(Type dataType, string ticker, Resolution? resolution, DateTimeZone timeZone, bool fillForward = false, decimal leverage = 1.0m)

{

// NOTE: Invoking methods on BaseData w/out setting the symbol may provide unexpected behavior

var baseInstance = dataType.GetBaseDataInstance();

if (!baseInstance.RequiresMapping())

{

var symbol = new Symbol(

SecurityIdentifier.GenerateBase(dataType, ticker, Market.USA, baseInstance.RequiresMapping()),

ticker);

return AddDataImpl(dataType, symbol, resolution, timeZone, fillForward, leverage);

}

// If we need a mappable ticker and we can't find one in the SymbolCache, throw

Symbol underlying;

if (!SymbolCache.TryGetSymbol(ticker, out underlying))

{

throw new InvalidOperationException($"The custom data type {dataType.Name} requires mapping, but the provided ticker is not in the cache. " +

$"Please add this custom data type using a Symbol or perform this call after " +

$"a Security has been added using AddEquity, AddForex, AddCfd, AddCrypto, AddFuture, AddOption or AddSecurity. " +

$"An example use case can be found in CustomDataAddDataRegressionAlgorithm");

}

return AddData(dataType, underlying, resolution, timeZone, fillForward, leverage);

}

/// <summary>

/// AddData a new user defined data source, requiring only the minimum config options.

/// This adds a Symbol to the `Underlying` property in the custom data Symbol object.

/// Use this method when adding custom data with a ticker from the past, such as "AOL"

/// before it became "TWX", or if you need to filter using custom data and place trades on the

/// Symbol associated with the custom data.

/// </summary>

/// <param name="dataType">Data source type</param>

/// <param name="underlying"></param>

/// <param name="resolution">Resolution of the Data Required</param>

/// <param name="timeZone">Specifies the time zone of the raw data</param>

/// <param name="fillForward">When no data available on a tradebar, return the last data that was generated</param>

/// <param name="leverage">Custom leverage per security</param>

/// <returns>The new <see cref="Security"/></returns>

/// <remarks>

/// We include three optional unused object parameters so that pythonnet chooses the intended method

/// correctly. Previously, calling the overloaded method that accepts a string would instead call this method.

/// Adding the three unused parameters makes it choose the correct method when using a string or Symbol. This is

/// due to pythonnet's method precedence, as viewable here: https://github.com/QuantConnect/pythonnet/blob/9e29755c54e6008cb016e3dd9d75fbd8cd19fcf7/src/runtime/methodbinder.cs#L215

/// </remarks>

[DocumentationAttribute(AddingData)]

public Security AddData(Type dataType, Symbol underlying, Resolution? resolution = null, DateTimeZone timeZone = null, bool fillForward = false, decimal leverage = 1.0m)

{

var symbol = QuantConnect.Symbol.CreateBase(dataType, underlying, Market.USA);

return AddDataImpl(dataType, symbol, resolution, timeZone, fillForward, leverage);

}

/// <summary>

/// AddData a new user defined data source including symbol properties and exchange hours,

/// all other vars are not required and will use defaults.

/// This overload reflects the C# equivalent for custom properties and market hours

/// </summary>

/// <param name="type">Data source type</param>

/// <param name="ticker">Key/Ticker for data</param>

/// <param name="properties">The properties of this new custom data</param>

/// <param name="exchangeHours">The Exchange hours of this symbol</param>

/// <param name="resolution">Resolution of the Data Required</param>

/// <param name="fillForward">When no data available on a tradebar, return the last data that was generated</param>

/// <param name="leverage">Custom leverage per security</param>

/// <returns>The new <see cref="Security"/></returns>

[DocumentationAttribute(AddingData)]

public Security AddData(PyObject type, string ticker, SymbolProperties properties, SecurityExchangeHours exchangeHours, Resolution? resolution = null, bool fillForward = false, decimal leverage = 1.0m)

{

// Get the right key for storage of base type symbols

var dataType = type.CreateType();

var key = SecurityIdentifier.GenerateBaseSymbol(dataType, ticker);

// Add entries to our Symbol Properties DB and MarketHours DB

SetDatabaseEntries(key, properties, exchangeHours);

// Then add the data

return AddData(dataType, ticker, resolution, null, fillForward, leverage);

}

/// <summary>

/// Creates and adds a new Future Option contract to the algorithm.

/// </summary>

/// <param name="futureSymbol">The Future canonical symbol (i.e. Symbol returned from <see cref="AddFuture"/>)</param>

/// <param name="optionFilter">Filter to apply to option contracts loaded as part of the universe</param>

/// <returns>The new Option security, containing a Future as its underlying.</returns>

/// <exception cref="ArgumentException">The symbol provided is not canonical.</exception>

[DocumentationAttribute(AddingData)]

public void AddFutureOption(Symbol futureSymbol, PyObject optionFilter)

{

Func<OptionFilterUniverse, OptionFilterUniverse> optionFilterUniverse;

if (!optionFilter.TryConvertToDelegate(out optionFilterUniverse))

{

throw new ArgumentException("Option contract universe filter provided is not a function");

}

AddFutureOption(futureSymbol, optionFilterUniverse);

}

/// <summary>

/// Adds the provided final Symbol with/without underlying set to the algorithm.

/// This method is meant for custom data types that require a ticker, but have no underlying Symbol.

/// Examples of data sources that meet this criteria are U.S. Treasury Yield Curve Rates and Trading Economics data

/// </summary>

/// <param name="dataType">Data source type</param>

/// <param name="symbol">Final symbol that includes underlying (if any)</param>

/// <param name="resolution">Resolution of the Data required</param>

/// <param name="timeZone">Specifies the time zone of the raw data</param>

/// <param name="fillForward">When no data available on a tradebar, return the last data that was generated</param>

/// <param name="leverage">Custom leverage per security</param>

/// <returns>The new <see cref="Security"/></returns>

private Security AddDataImpl(Type dataType, Symbol symbol, Resolution? resolution, DateTimeZone timeZone, bool fillForward, decimal leverage)

{

var alias = symbol.ID.Symbol;

SymbolCache.Set(alias, symbol);

if (timeZone != null)

{

// user set time zone

MarketHoursDatabase.SetEntryAlwaysOpen(Market.USA, alias, SecurityType.Base, timeZone);

}

//Add this new generic data as a tradeable security:

var config = SubscriptionManager.SubscriptionDataConfigService.Add(

dataType,

symbol,

resolution,

fillForward,

isCustomData: true,

extendedMarketHours: true);

var security = Securities.CreateSecurity(symbol, config, leverage, addToSymbolCache: false);

return AddToUserDefinedUniverse(security, new List<SubscriptionDataConfig> { config });

}

/// <summary>

/// Creates a new universe and adds it to the algorithm. This is for coarse fundamental US Equity data and

/// will be executed on day changes in the NewYork time zone (<see cref="TimeZones.NewYork"/>

/// </summary>

/// <param name="pyObject">Defines an initial coarse selection</param>

[DocumentationAttribute(Universes)]

public Universe AddUniverse(PyObject pyObject)

{

Func<IEnumerable<CoarseFundamental>, object> coarseFunc;

Universe universe;

// TODO: to be removed when https://github.com/QuantConnect/pythonnet/issues/62 is solved

if (pyObject.TryConvert(out universe))

{

return AddUniverse(universe);

}

else if (pyObject.TryConvert(out universe, allowPythonDerivative: true))

{

return AddUniverse(new UniversePythonWrapper(pyObject));

}

else if (pyObject.TryConvertToDelegate(out coarseFunc))

{

return AddUniverse(coarseFunc.ConvertToUniverseSelectionSymbolDelegate());

}

else

{

using (Py.GIL())

{

throw new ArgumentException($"QCAlgorithm.AddUniverse: {pyObject.Repr()} is not a valid argument.");

}

}

}

/// <summary>

/// Creates a new universe and adds it to the algorithm. This is for coarse and fine fundamental US Equity data and

/// will be executed on day changes in the NewYork time zone (<see cref="TimeZones.NewYork"/>

/// </summary>

/// <param name="pyObject">Defines an initial coarse selection or a universe</param>

/// <param name="pyfine">Defines a more detailed selection with access to more data</param>

[DocumentationAttribute(Universes)]

public Universe AddUniverse(PyObject pyObject, PyObject pyfine)

{

Func<IEnumerable<CoarseFundamental>, object> coarseFunc;

Func<IEnumerable<FineFundamental>, object> fineFunc;

Universe universe;

if (pyObject.TryConvert(out universe) && pyfine.TryConvertToDelegate(out fineFunc))

{

return AddUniverse(universe, fineFunc.ConvertToUniverseSelectionSymbolDelegate());

}

else if (pyObject.TryConvertToDelegate(out coarseFunc) && pyfine.TryConvertToDelegate(out fineFunc))

{

return AddUniverse(coarseFunc.ConvertToUniverseSelectionSymbolDelegate(),

fineFunc.ConvertToUniverseSelectionSymbolDelegate());

}

else

{

using (Py.GIL())

{

throw new ArgumentException($"QCAlgorithm.AddUniverse: {pyObject.Repr()} or {pyfine.Repr()} is not a valid argument.");

}

}

}

/// <summary>

/// Creates a new universe and adds it to the algorithm. This can be used to return a list of string

/// symbols retrieved from anywhere and will loads those symbols under the US Equity market.

/// </summary>

/// <param name="name">A unique name for this universe</param>

/// <param name="resolution">The resolution this universe should be triggered on</param>

/// <param name="pySelector">Function delegate that accepts a DateTime and returns a collection of string symbols</param>

[DocumentationAttribute(Universes)]

public Universe AddUniverse(string name, Resolution resolution, PyObject pySelector)

{

var selector = pySelector.ConvertToDelegate<Func<DateTime, object>>();

return AddUniverse(name, resolution, selector.ConvertToUniverseSelectionStringDelegate());

}

/// <summary>

/// Creates a new universe and adds it to the algorithm. This can be used to return a list of string

/// symbols retrieved from anywhere and will loads those symbols under the US Equity market.

/// </summary>

/// <param name="name">A unique name for this universe</param>

/// <param name="pySelector">Function delegate that accepts a DateTime and returns a collection of string symbols</param>

[DocumentationAttribute(Universes)]

public Universe AddUniverse(string name, PyObject pySelector)

{

var selector = pySelector.ConvertToDelegate<Func<DateTime, object>>();

return AddUniverse(name, selector.ConvertToUniverseSelectionStringDelegate());

}

/// <summary>

/// Creates a new user defined universe that will fire on the requested resolution during market hours.

/// </summary>

/// <param name="securityType">The security type of the universe</param>

/// <param name="name">A unique name for this universe</param>

/// <param name="resolution">The resolution this universe should be triggered on</param>

/// <param name="market">The market of the universe</param>

/// <param name="universeSettings">The subscription settings used for securities added from this universe</param>

/// <param name="pySelector">Function delegate that accepts a DateTime and returns a collection of string symbols</param>

[DocumentationAttribute(Universes)]

public Universe AddUniverse(SecurityType securityType, string name, Resolution resolution, string market, UniverseSettings universeSettings, PyObject pySelector)

{

var selector = pySelector.ConvertToDelegate<Func<DateTime, object>>();

return AddUniverse(securityType, name, resolution, market, universeSettings, selector.ConvertToUniverseSelectionStringDelegate());

}

/// <summary>

/// Creates a new universe and adds it to the algorithm. This will use the default universe settings

/// specified via the <see cref="UniverseSettings"/> property. This universe will use the defaults

/// of SecurityType.Equity, Resolution.Daily, Market.USA, and UniverseSettings

/// </summary>

/// <param name="T">The data type</param>

/// <param name="name">A unique name for this universe</param>

/// <param name="selector">Function delegate that performs selection on the universe data</param>

[DocumentationAttribute(Universes)]

public Universe AddUniverse(PyObject T, string name, PyObject selector)

{

return AddUniverse(T.CreateType(), SecurityType.Equity, name, Resolution.Daily, Market.USA, UniverseSettings, selector);

}

/// <summary>

/// Creates a new universe and adds it to the algorithm. This will use the default universe settings

/// specified via the <see cref="UniverseSettings"/> property. This universe will use the defaults

/// of SecurityType.Equity, Market.USA and UniverseSettings

/// </summary>

/// <param name="T">The data type</param>

/// <param name="name">A unique name for this universe</param>

/// <param name="resolution">The expected resolution of the universe data</param>

/// <param name="selector">Function delegate that performs selection on the universe data</param>

[DocumentationAttribute(Universes)]

public Universe AddUniverse(PyObject T, string name, Resolution resolution, PyObject selector)

{

return AddUniverse(T.CreateType(), SecurityType.Equity, name, resolution, Market.USA, UniverseSettings, selector);

}

/// <summary>

/// Creates a new universe and adds it to the algorithm. This will use the default universe settings

/// specified via the <see cref="UniverseSettings"/> property. This universe will use the defaults

/// of SecurityType.Equity, and Market.USA

/// </summary>

/// <param name="T">The data type</param>

/// <param name="name">A unique name for this universe</param>

/// <param name="resolution">The expected resolution of the universe data</param>

/// <param name="universeSettings">The settings used for securities added by this universe</param>

/// <param name="selector">Function delegate that performs selection on the universe data</param>

[DocumentationAttribute(Universes)]

public Universe AddUniverse(PyObject T, string name, Resolution resolution, UniverseSettings universeSettings, PyObject selector)

{

return AddUniverse(T.CreateType(), SecurityType.Equity, name, resolution, Market.USA, universeSettings, selector);

}

/// <summary>

/// Creates a new universe and adds it to the algorithm. This will use the default universe settings

/// specified via the <see cref="UniverseSettings"/> property. This universe will use the defaults

/// of SecurityType.Equity, Resolution.Daily, and Market.USA

/// </summary>

/// <param name="T">The data type</param>

/// <param name="name">A unique name for this universe</param>

/// <param name="universeSettings">The settings used for securities added by this universe</param>

/// <param name="selector">Function delegate that performs selection on the universe data</param>

[DocumentationAttribute(Universes)]

public Universe AddUniverse(PyObject T, string name, UniverseSettings universeSettings, PyObject selector)

{

return AddUniverse(T.CreateType(), SecurityType.Equity, name, Resolution.Daily, Market.USA, universeSettings, selector);

}

/// <summary>

/// Creates a new universe and adds it to the algorithm. This will use the default universe settings

/// specified via the <see cref="UniverseSettings"/> property.

/// </summary>

/// <param name="T">The data type</param>

/// <param name="securityType">The security type the universe produces</param>

/// <param name="name">A unique name for this universe</param>

/// <param name="resolution">The expected resolution of the universe data</param>

/// <param name="market">The market for selected symbols</param>

/// <param name="selector">Function delegate that performs selection on the universe data</param>

[DocumentationAttribute(Universes)]

public Universe AddUniverse(PyObject T, SecurityType securityType, string name, Resolution resolution, string market, PyObject selector)

{

return AddUniverse(T.CreateType(), securityType, name, resolution, market, UniverseSettings, selector);

}

/// <summary>

/// Creates a new universe and adds it to the algorithm

/// </summary>

/// <param name="T">The data type</param>

/// <param name="securityType">The security type the universe produces</param>

/// <param name="name">A unique name for this universe</param>

/// <param name="resolution">The expected resolution of the universe data</param>

/// <param name="market">The market for selected symbols</param>

/// <param name="universeSettings">The subscription settings to use for newly created subscriptions</param>

/// <param name="selector">Function delegate that performs selection on the universe data</param>

[DocumentationAttribute(Universes)]

public Universe AddUniverse(PyObject T, SecurityType securityType, string name, Resolution resolution, string market, UniverseSettings universeSettings, PyObject selector)

{

return AddUniverse(T.CreateType(), securityType, name, resolution, market, universeSettings, selector);

}

/// <summary>

/// Creates a new universe and adds it to the algorithm

/// </summary>

/// <param name="dataType">The data type</param>

/// <param name="securityType">The security type the universe produces</param>

/// <param name="name">A unique name for this universe</param>

/// <param name="resolution">The expected resolution of the universe data</param>

/// <param name="market">The market for selected symbols</param>

/// <param name="universeSettings">The subscription settings to use for newly created subscriptions</param>

/// <param name="pySelector">Function delegate that performs selection on the universe data</param>

[DocumentationAttribute(Universes)]

public Universe AddUniverse(Type dataType, SecurityType securityType, string name, Resolution resolution, string market, UniverseSettings universeSettings, PyObject pySelector)

{

var marketHoursDbEntry = MarketHoursDatabase.GetEntry(market, name, securityType);

var dataTimeZone = marketHoursDbEntry.DataTimeZone;

var exchangeTimeZone = marketHoursDbEntry.ExchangeHours.TimeZone;

var symbol = QuantConnect.Symbol.Create(name, securityType, market, baseDataType: dataType);

var config = new SubscriptionDataConfig(dataType, symbol, resolution, dataTimeZone, exchangeTimeZone, false, false, true, true, isFilteredSubscription: false);

var selector = pySelector.ConvertToDelegate<Func<IEnumerable<IBaseData>, object>>();

return AddUniverse(new FuncUniverse(config, universeSettings, baseDatas =>

{

var result = selector(baseDatas);

return ReferenceEquals(result, Universe.Unchanged)

? Universe.Unchanged : ((object[])result)

.Select(x => x is Symbol ? (Symbol)x : QuantConnect.Symbol.Create((string)x, securityType, market, baseDataType: dataType));

}

));

}

/// <summary>

/// Creates a new universe selection model and adds it to the algorithm. This universe selection model will chain to the security

/// changes of a given <see cref="Universe"/> selection output and create a new <see cref="OptionChainUniverse"/> for each of them

/// </summary>

/// <param name="universe">The universe we want to chain an option universe selection model too</param>

/// <param name="optionFilter">The option filter universe to use</param>

[DocumentationAttribute(Universes)]

public void AddUniverseOptions(PyObject universe, PyObject optionFilter)

{

Func<OptionFilterUniverse, OptionFilterUniverse> convertedOptionChain;

Universe universeToChain;

if (universe.TryConvert(out universeToChain) && optionFilter.TryConvertToDelegate(out convertedOptionChain))

{

AddUniverseOptions(universeToChain, convertedOptionChain);

}

else

{

using (Py.GIL())

{

throw new ArgumentException($"QCAlgorithm.AddChainedEquityOptionUniverseSelectionModel: {universe.Repr()} or {optionFilter.Repr()} is not a valid argument.");

}

}

}

/// <summary>

/// Registers the consolidator to receive automatic updates as well as configures the indicator to receive updates

/// from the consolidator.

/// </summary>

/// <param name="symbol">The symbol to register against</param>

/// <param name="indicator">The indicator to receive data from the consolidator</param>

/// <param name="resolution">The resolution at which to send data to the indicator, null to use the same resolution as the subscription</param>

/// <param name="selector">Selects a value from the BaseData send into the indicator, if null defaults to a cast (x => (T)x)</param>

[DocumentationAttribute(Indicators)]

[DocumentationAttribute(ConsolidatingData)]

public void RegisterIndicator(Symbol symbol, PyObject indicator, Resolution? resolution = null, PyObject selector = null)

{

RegisterIndicator(symbol, indicator, ResolveConsolidator(symbol, resolution), selector);

}

/// <summary>

/// Registers the consolidator to receive automatic updates as well as configures the indicator to receive updates

/// from the consolidator.

/// </summary>

/// <param name="symbol">The symbol to register against</param>

/// <param name="indicator">The indicator to receive data from the consolidator</param>

/// <param name="resolution">The resolution at which to send data to the indicator, null to use the same resolution as the subscription</param>

/// <param name="selector">Selects a value from the BaseData send into the indicator, if null defaults to a cast (x => (T)x)</param>

[DocumentationAttribute(Indicators)]

[DocumentationAttribute(ConsolidatingData)]

public void RegisterIndicator(Symbol symbol, PyObject indicator, TimeSpan? resolution = null, PyObject selector = null)

{

RegisterIndicator(symbol, indicator, ResolveConsolidator(symbol, resolution), selector);

}

/// <summary>

/// Registers the consolidator to receive automatic updates as well as configures the indicator to receive updates

/// from the consolidator.

/// </summary>

/// <param name="symbol">The symbol to register against</param>

/// <param name="indicator">The indicator to receive data from the consolidator</param>

/// <param name="pyObject">The python object that it is trying to register with, could be consolidator or a timespan</param>

/// <param name="selector">Selects a value from the BaseData send into the indicator, if null defaults to a cast (x => (T)x)</param>

[DocumentationAttribute(Indicators)]

[DocumentationAttribute(ConsolidatingData)]

public void RegisterIndicator(Symbol symbol, PyObject indicator, PyObject pyObject, PyObject selector = null)

{

try

{

// First check if this is just a regular IDataConsolidator

IDataConsolidator dataConsolidator;

if (!pyObject.TryConvert(out dataConsolidator))

{

// If not then try and wrap it as a custom Python consolidator

dataConsolidator = new DataConsolidatorPythonWrapper(pyObject);

}

RegisterIndicator(symbol, indicator, dataConsolidator, selector);

return;

}

catch

{

}

// Finally, since above didn't work, just try it as a timespan

// Issue #4668 Fix

using (Py.GIL())

{

try

{

// tryConvert does not work for timespan

TimeSpan? timeSpan = pyObject.As<TimeSpan>();

if (timeSpan != default(TimeSpan))

{

RegisterIndicator(symbol, indicator, timeSpan, selector);

}

}

catch

{

throw new ArgumentException("Invalid third argument, should be either a valid consolidator or timedelta object");

}

}

}

/// <summary>

/// Registers the consolidator to receive automatic updates as well as configures the indicator to receive updates

/// from the consolidator.

/// </summary>

/// <param name="symbol">The symbol to register against</param>

/// <param name="indicator">The indicator to receive data from the consolidator</param>

/// <param name="consolidator">The consolidator to receive raw subscription data</param>

/// <param name="selector">Selects a value from the BaseData send into the indicator, if null defaults to a cast (x => (T)x)</param>

[DocumentationAttribute(Indicators)]

[DocumentationAttribute(ConsolidatingData)]

public void RegisterIndicator(Symbol symbol, PyObject indicator, IDataConsolidator consolidator, PyObject selector = null)

{

// TODO: to be removed when https://github.com/QuantConnect/pythonnet/issues/62 is solved

IndicatorBase<IndicatorDataPoint> indicatorDataPoint;

IndicatorBase<IBaseDataBar> indicatorDataBar;

IndicatorBase<TradeBar> indicatorTradeBar;

if (indicator.TryConvert(out indicatorDataPoint))

{

RegisterIndicator(symbol, indicatorDataPoint, consolidator, selector?.ConvertToDelegate<Func<IBaseData, decimal>>());

return;

}

else if (indicator.TryConvert(out indicatorDataBar))

{

RegisterIndicator(symbol, indicatorDataBar, consolidator, selector?.ConvertToDelegate<Func<IBaseData, IBaseDataBar>>());

return;

}

else if (indicator.TryConvert(out indicatorTradeBar))

{

RegisterIndicator(symbol, indicatorTradeBar, consolidator, selector?.ConvertToDelegate<Func<IBaseData, TradeBar>>());

return;

}

RegisterIndicator(symbol, WrapPythonIndicator(indicator), consolidator, selector?.ConvertToDelegate<Func<IBaseData, IBaseData>>());

}

/// <summary>

/// Warms up a given indicator with historical data

/// </summary>

/// <param name="symbol">The symbol whose indicator we want</param>

/// <param name="indicator">The indicator we want to warm up</param>

/// <param name="resolution">The resolution</param>

/// <param name="selector">Selects a value from the BaseData send into the indicator, if null defaults to a cast (x => (T)x)</param>

[DocumentationAttribute(Indicators)]

[DocumentationAttribute(HistoricalData)]

public void WarmUpIndicator(Symbol symbol, PyObject indicator, Resolution? resolution = null, PyObject selector = null)

{

// TODO: to be removed when https://github.com/QuantConnect/pythonnet/issues/62 is solved

if (indicator.TryConvert(out IndicatorBase<IndicatorDataPoint> indicatorDataPoint))

{

WarmUpIndicator(symbol, indicatorDataPoint, resolution, selector?.ConvertToDelegate<Func<IBaseData, decimal>>());

return;

}

if (indicator.TryConvert(out IndicatorBase<IBaseDataBar> indicatorDataBar))

{

WarmUpIndicator(symbol, indicatorDataBar, resolution, selector?.ConvertToDelegate<Func<IBaseData, IBaseDataBar>>());

return;

}

if (indicator.TryConvert(out IndicatorBase<TradeBar> indicatorTradeBar))

{

WarmUpIndicator(symbol, indicatorTradeBar, resolution, selector?.ConvertToDelegate<Func<IBaseData, TradeBar>>());

return;

}

WarmUpIndicator(symbol, WrapPythonIndicator(indicator), resolution, selector?.ConvertToDelegate<Func<IBaseData, IBaseData>>());

}

/// <summary>

/// Plot a chart using string series name, with value.

/// </summary>

/// <param name="series">Name of the plot series</param>

/// <param name="pyObject">PyObject with the value to plot</param>

/// <seealso cref="Plot(string,decimal)"/>

[DocumentationAttribute(Charting)]

public void Plot(string series, PyObject pyObject)

{

using (Py.GIL())

{

if (pyObject.TryConvert(out IndicatorBase indicator, true))

{

Plot(series, indicator);

}

else

{

try

{

var value = (((dynamic)pyObject).Value as PyObject).GetAndDispose<decimal>();

Plot(series, value);

}

catch

{

var pythonType = pyObject.GetPythonType().Repr();

throw new ArgumentException($"QCAlgorithm.Plot(): The last argument should be a QuantConnect Indicator object, {pythonType} was provided.");

}

}

}

}

/// <summary>

/// Plots the value of each indicator on the chart

/// </summary>

/// <param name="chart">The chart's name</param>

/// <param name="first">The first indicator to plot</param>

/// <param name="second">The second indicator to plot</param>

/// <param name="third">The third indicator to plot</param>

/// <param name="fourth">The fourth indicator to plot</param>

/// <seealso cref="Plot(string,string,decimal)"/>

[DocumentationAttribute(Charting)]

public void Plot(string chart, Indicator first, Indicator second = null, Indicator third = null, Indicator fourth = null)

{

Plot(chart, new[] { first, second, third, fourth }.Where(x => x != null).ToArray());

}

/// <summary>

/// Plots the value of each indicator on the chart

/// </summary>

/// <param name="chart">The chart's name</param>

/// <param name="first">The first indicator to plot</param>

/// <param name="second">The second indicator to plot</param>

/// <param name="third">The third indicator to plot</param>

/// <param name="fourth">The fourth indicator to plot</param>

/// <seealso cref="Plot(string,string,decimal)"/>

[DocumentationAttribute(Charting)]

public void Plot(string chart, BarIndicator first, BarIndicator second = null, BarIndicator third = null, BarIndicator fourth = null)

{

Plot(chart, new[] { first, second, third, fourth }.Where(x => x != null).ToArray());

}

/// <summary>

/// Plots the value of each indicator on the chart

/// </summary>

/// <param name="chart">The chart's name</param>

/// <param name="first">The first indicator to plot</param>

/// <param name="second">The second indicator to plot</param>

/// <param name="third">The third indicator to plot</param>

/// <param name="fourth">The fourth indicator to plot</param>

/// <seealso cref="Plot(string,string,decimal)"/>

[DocumentationAttribute(Charting)]

public void Plot(string chart, TradeBarIndicator first, TradeBarIndicator second = null, TradeBarIndicator third = null, TradeBarIndicator fourth = null)

{

Plot(chart, new[] { first, second, third, fourth }.Where(x => x != null).ToArray());

}

/// <summary>

/// Automatically plots each indicator when a new value is available

/// </summary>

[DocumentationAttribute(Charting)]

[DocumentationAttribute(Indicators)]

public void PlotIndicator(string chart, PyObject first, PyObject second = null, PyObject third = null, PyObject fourth = null)

{

var array = GetIndicatorArray(first, second, third, fourth);

PlotIndicator(chart, array[0], array[1], array[2], array[3]);

}

/// <summary>

/// Automatically plots each indicator when a new value is available

/// </summary>

[DocumentationAttribute(Charting)]

[DocumentationAttribute(Indicators)]

public void PlotIndicator(string chart, bool waitForReady, PyObject first, PyObject second = null, PyObject third = null, PyObject fourth = null)

{

var array = GetIndicatorArray(first, second, third, fourth);

PlotIndicator(chart, waitForReady, array[0], array[1], array[2], array[3]);

}

/// <summary>

/// Creates a new FilteredIdentity indicator for the symbol The indicator will be automatically

/// updated on the symbol's subscription resolution

/// </summary>

/// <param name="symbol">The symbol whose values we want as an indicator</param>

/// <param name="selector">Selects a value from the BaseData, if null defaults to the .Value property (x => x.Value)</param>

/// <param name="filter">Filters the IBaseData send into the indicator, if null defaults to true (x => true) which means no filter</param>

/// <param name="fieldName">The name of the field being selected</param>

/// <returns>A new FilteredIdentity indicator for the specified symbol and selector</returns>

[DocumentationAttribute(Indicators)]

public FilteredIdentity FilteredIdentity(Symbol symbol, PyObject selector = null, PyObject filter = null, string fieldName = null)

{

var resolution = GetSubscription(symbol).Resolution;

return FilteredIdentity(symbol, resolution, selector, filter, fieldName);

}

/// <summary>

/// Creates a new FilteredIdentity indicator for the symbol The indicator will be automatically

/// updated on the symbol's subscription resolution

/// </summary>

/// <param name="symbol">The symbol whose values we want as an indicator</param>

/// <param name="resolution">The desired resolution of the data</param>

/// <param name="selector">Selects a value from the BaseData, if null defaults to the .Value property (x => x.Value)</param>

/// <param name="filter">Filters the IBaseData send into the indicator, if null defaults to true (x => true) which means no filter</param>

/// <param name="fieldName">The name of the field being selected</param>

/// <returns>A new FilteredIdentity indicator for the specified symbol and selector</returns>

[DocumentationAttribute(Indicators)]

public FilteredIdentity FilteredIdentity(Symbol symbol, Resolution resolution, PyObject selector = null, PyObject filter = null, string fieldName = null)

{

var name = CreateIndicatorName(symbol, fieldName ?? "close", resolution);

var pyselector = PythonUtil.ToFunc<IBaseData, IBaseDataBar>(selector);

var pyfilter = PythonUtil.ToFunc<IBaseData, bool>(filter);

var filteredIdentity = new FilteredIdentity(name, pyfilter);

RegisterIndicator(symbol, filteredIdentity, resolution, pyselector);

return filteredIdentity;

}

/// <summary>

/// Creates a new FilteredIdentity indicator for the symbol The indicator will be automatically

/// updated on the symbol's subscription resolution

/// </summary>

/// <param name="symbol">The symbol whose values we want as an indicator</param>

/// <param name="resolution">The desired resolution of the data</param>

/// <param name="selector">Selects a value from the BaseData, if null defaults to the .Value property (x => x.Value)</param>

/// <param name="filter">Filters the IBaseData send into the indicator, if null defaults to true (x => true) which means no filter</param>

/// <param name="fieldName">The name of the field being selected</param>

/// <returns>A new FilteredIdentity indicator for the specified symbol and selector</returns>

[DocumentationAttribute(Indicators)]

public FilteredIdentity FilteredIdentity(Symbol symbol, TimeSpan resolution, PyObject selector = null, PyObject filter = null, string fieldName = null)

{

var name = $"{symbol}({fieldName ?? "close"}_{resolution.ToStringInvariant(null)})";

var pyselector = PythonUtil.ToFunc<IBaseData, IBaseDataBar>(selector);

var pyfilter = PythonUtil.ToFunc<IBaseData, bool>(filter);

var filteredIdentity = new FilteredIdentity(name, pyfilter);

RegisterIndicator(symbol, filteredIdentity, ResolveConsolidator(symbol, resolution), pyselector);

return filteredIdentity;

}

/// <summary>

/// Gets the historical data for the specified symbol. The exact number of bars will be returned.

/// The symbol must exist in the Securities collection.

/// </summary>

/// <param name="tickers">The symbols to retrieve historical data for</param>

/// <param name="periods">The number of bars to request</param>

/// <param name="resolution">The resolution to request</param>

/// <param name="fillForward">True to fill forward missing data, false otherwise</param>

/// <returns>A python dictionary with pandas DataFrame containing the requested historical data</returns>

[DocumentationAttribute(HistoricalData)]

public PyObject History(PyObject tickers, int periods, Resolution? resolution = null, bool? fillForward = null)

{

var symbols = tickers.ConvertToSymbolEnumerable();

return GetDataFrame(History(symbols, periods, resolution, fillForward));

}

/// <summary>

/// Gets the historical data for the specified symbols over the requested span.

/// The symbols must exist in the Securities collection.

/// </summary>

/// <param name="tickers">The symbols to retrieve historical data for</param>

/// <param name="span">The span over which to retrieve recent historical data</param>

/// <param name="resolution">The resolution to request</param>

/// <param name="fillForward">True to fill forward missing data, false otherwise</param>

/// <returns>A python dictionary with pandas DataFrame containing the requested historical data</returns>

[DocumentationAttribute(HistoricalData)]

public PyObject History(PyObject tickers, TimeSpan span, Resolution? resolution = null, bool? fillForward = null)

{

var symbols = tickers.ConvertToSymbolEnumerable();

return GetDataFrame(History(symbols, span, resolution, fillForward));

}

/// <summary>

/// Gets the historical data for the specified symbols between the specified dates. The symbols must exist in the Securities collection.

/// </summary>

/// <param name="tickers">The symbols to retrieve historical data for</param>

/// <param name="start">The start time in the algorithm's time zone</param>

/// <param name="end">The end time in the algorithm's time zone</param>

/// <param name="resolution">The resolution to request</param>

/// <param name="fillForward">True to fill forward missing data, false otherwise</param>

/// <param name="extendedMarket">True to include extended market hours data, false otherwise</param>

/// <param name="dataMappingMode">The contract mapping mode to use for the security history request</param>

/// <param name="dataNormalizationMode">The price scaling mode to use for the securities history</param>

/// <param name="contractDepthOffset">The continuous contract desired offset from the current front month.

/// For example, 0 (default) will use the front month, 1 will use the back month contract</param>

/// <returns>A python dictionary with a pandas DataFrame containing the requested historical data</returns>

[DocumentationAttribute(HistoricalData)]

public PyObject History(PyObject tickers, DateTime start, DateTime end, Resolution? resolution = null, bool? fillForward = null,

bool? extendedMarket = null, DataMappingMode? dataMappingMode = null, DataNormalizationMode? dataNormalizationMode = null,

int? contractDepthOffset = null)

{

var symbols = tickers.ConvertToSymbolEnumerable();

return GetDataFrame(History(symbols, start, end, resolution, fillForward, extendedMarket, dataMappingMode,

dataNormalizationMode, contractDepthOffset));

}

/// <summary>

/// Gets the historical data for the specified symbol between the specified dates. The symbol must exist in the Securities collection.

/// </summary>

/// <param name="tickers">The symbols to retrieve historical data for</param>

/// <param name="start">The start time in the algorithm's time zone</param>

/// <param name="end">The end time in the algorithm's time zone</param>

/// <param name="resolution">The resolution to request</param>

/// <returns>A python dictionary with pandas DataFrame containing the requested historical data</returns>

[DocumentationAttribute(HistoricalData)]

public PyObject History(PyObject tickers, DateTime start, DateTime end, Resolution? resolution = null)

{

var symbols = tickers.ConvertToSymbolEnumerable();

return GetDataFrame(History(symbols, start, end, resolution));

}