wehub-resource-sync
338 lines
15 KiB
C#
338 lines
15 KiB
C#
/*
|
|
* QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
|
|
* Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using QuantConnect.Data.Consolidators;
|
|
using QuantConnect.Data.Custom.IconicTypes;
|
|
using QuantConnect.Data.Market;
|
|
using QuantConnect.Data.UniverseSelection;
|
|
using QuantConnect.Util;
|
|
|
|
namespace QuantConnect.Data
|
|
{
|
|
/// <summary>
|
|
/// Provides extension methods to slices and slice enumerables
|
|
/// </summary>
|
|
public static class SliceExtensions
|
|
{
|
|
/// <summary>
|
|
/// Selects into the slice and returns the TradeBars that have data in order
|
|
/// </summary>
|
|
/// <param name="slices">The enumerable of slice</param>
|
|
/// <returns>An enumerable of TradeBars</returns>
|
|
public static IEnumerable<TradeBars> TradeBars(this IEnumerable<Slice> slices)
|
|
{
|
|
return slices.Where(x => x.Bars.Count > 0).Select(x => x.Bars);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Selects into the slice and returns the Ticks that have data in order
|
|
/// </summary>
|
|
/// <param name="slices">The enumerable of slice</param>
|
|
/// <returns>An enumerable of Ticks</returns>
|
|
public static IEnumerable<Ticks> Ticks(this IEnumerable<Slice> slices)
|
|
{
|
|
return slices.Where(x => x.Ticks.Count > 0).Select(x => x.Ticks);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the data dictionaries or points of the requested type in each slice
|
|
/// </summary>
|
|
/// <param name="slices">The enumerable of slice</param>
|
|
/// <returns>An enumerable of data dictionary or data point of the requested type</returns>
|
|
public static IEnumerable<DataDictionary<BaseDataCollection>> GetUniverseData(this IEnumerable<Slice> slices)
|
|
{
|
|
return slices.SelectMany(x => x.AllData).Select(x =>
|
|
{
|
|
// we wrap the universe data collection into a data dictionary so it fits the api pattern
|
|
return new DataDictionary<BaseDataCollection>(new[] { (BaseDataCollection)x }, (y) => y.Symbol);
|
|
});
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the data dictionaries or points of the requested type in each slice
|
|
/// </summary>
|
|
/// <param name="slices">The enumerable of slice</param>
|
|
/// <param name="type">Data type of the data that will be fetched</param>
|
|
/// <param name="symbol">The symbol to retrieve</param>
|
|
/// <returns>An enumerable of data dictionary or data point of the requested type</returns>
|
|
public static IEnumerable<dynamic> Get(this IEnumerable<Slice> slices, Type type, Symbol symbol = null)
|
|
{
|
|
var result = slices.Select(x => x.Get(type));
|
|
|
|
if (symbol == null)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
return result.Where(x => x.ContainsKey(symbol)).Select(x => x[symbol]);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets an enumerable of TradeBar for the given symbol. This method does not verify
|
|
/// that the specified symbol points to a TradeBar
|
|
/// </summary>
|
|
/// <param name="slices">The enumerable of slice</param>
|
|
/// <param name="symbol">The symbol to retrieve</param>
|
|
/// <returns>An enumerable of TradeBar for the matching symbol, of no TradeBar found for symbol, empty enumerable is returned</returns>
|
|
public static IEnumerable<TradeBar> Get(this IEnumerable<Slice> slices, Symbol symbol)
|
|
{
|
|
return slices.TradeBars().Where(x => x.ContainsKey(symbol)).Select(x => x[symbol]);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets an enumerable of T for the given symbol. This method does not vify
|
|
/// that the specified symbol points to a T
|
|
/// </summary>
|
|
/// <typeparam name="T">The data type</typeparam>
|
|
/// <param name="dataDictionaries">The data dictionary enumerable to access</param>
|
|
/// <param name="symbol">The symbol to retrieve</param>
|
|
/// <returns>An enumerable of T for the matching symbol, if no T is found for symbol, empty enumerable is returned</returns>
|
|
public static IEnumerable<T> Get<T>(this IEnumerable<DataDictionary<T>> dataDictionaries, Symbol symbol)
|
|
where T : IBaseData
|
|
{
|
|
return dataDictionaries.Where(x => x.ContainsKey(symbol)).Select(x => x[symbol]);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets an enumerable of decimals by accessing the specified field on data for the symbol
|
|
/// </summary>
|
|
/// <typeparam name="T">The data type</typeparam>
|
|
/// <param name="dataDictionaries">An enumerable of data dictionaries</param>
|
|
/// <param name="symbol">The symbol to retrieve</param>
|
|
/// <param name="field">The field to access</param>
|
|
/// <returns>An enumerable of decimals</returns>
|
|
public static IEnumerable<decimal> Get<T>(this IEnumerable<DataDictionary<T>> dataDictionaries, Symbol symbol, string field)
|
|
{
|
|
Func<T, decimal> selector;
|
|
if (typeof (DynamicData).IsAssignableFrom(typeof (T)))
|
|
{
|
|
selector = data =>
|
|
{
|
|
var dyn = (DynamicData) (object) data;
|
|
return (decimal) dyn.GetProperty(field);
|
|
};
|
|
}
|
|
else if (typeof (T) == typeof (List<Tick>))
|
|
{
|
|
// perform the selection on the last tick
|
|
// NOTE: This is a known bug, should be updated to perform the selection on each item in the list
|
|
var dataSelector = (Func<Tick, decimal>) ExpressionBuilder.MakePropertyOrFieldSelector(typeof (Tick), field).Compile();
|
|
selector = ticks => dataSelector(((List<Tick>) (object) ticks).Last());
|
|
}
|
|
else
|
|
{
|
|
selector = (Func<T, decimal>) ExpressionBuilder.MakePropertyOrFieldSelector(typeof (T), field).Compile();
|
|
}
|
|
|
|
foreach (var dataDictionary in dataDictionaries)
|
|
{
|
|
T item;
|
|
if (dataDictionary.TryGetValue(symbol, out item))
|
|
{
|
|
yield return selector(item);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the data dictionaries of the requested type in each slice
|
|
/// </summary>
|
|
/// <typeparam name="T">The data type</typeparam>
|
|
/// <param name="slices">The enumerable of slice</param>
|
|
/// <returns>An enumerable of data dictionary of the requested type</returns>
|
|
public static IEnumerable<DataDictionary<T>> Get<T>(this IEnumerable<Slice> slices)
|
|
where T : IBaseData
|
|
{
|
|
return slices.Select(x => x.Get<T>()).Where(x => x.Count > 0);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets an enumerable of T by accessing the slices for the requested symbol
|
|
/// </summary>
|
|
/// <typeparam name="T">The data type</typeparam>
|
|
/// <param name="slices">The enumerable of slice</param>
|
|
/// <param name="symbol">The symbol to retrieve</param>
|
|
/// <returns>An enumerable of T by accessing each slice for the requested symbol</returns>
|
|
public static IEnumerable<T> Get<T>(this IEnumerable<Slice> slices, Symbol symbol)
|
|
where T : IBaseData
|
|
{
|
|
return slices.Select(x => x.Get<T>()).Where(x => x.ContainsKey(symbol)).Select(x => x[symbol]);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets an enumerable of decimal by accessing the slice for the symbol and then retrieving the specified
|
|
/// field on each piece of data
|
|
/// </summary>
|
|
/// <param name="slices">The enumerable of slice</param>
|
|
/// <param name="symbol">The symbol to retrieve</param>
|
|
/// <param name="field">The field selector used to access the dats</param>
|
|
/// <returns>An enumerable of decimal</returns>
|
|
public static IEnumerable<decimal> Get(this IEnumerable<Slice> slices, Symbol symbol, Func<BaseData, decimal> field)
|
|
{
|
|
foreach (var slice in slices)
|
|
{
|
|
dynamic item;
|
|
if (slice.TryGetValue(symbol, out item))
|
|
{
|
|
if (item is List<Tick>) yield return field(item.Last());
|
|
else yield return field(item);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Tries to get the data for the specified symbol and type
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of data we want, for example, <see cref="TradeBar"/> or <see cref="UnlinkedData"/>, etc...</typeparam>
|
|
/// <param name="slice">The slice</param>
|
|
/// <param name="symbol">The symbol data is sought for</param>
|
|
/// <param name="data">The found data</param>
|
|
/// <returns>True if data was found for the specified type and symbol</returns>
|
|
public static bool TryGet<T>(this Slice slice, Symbol symbol, out T data)
|
|
where T : IBaseData
|
|
{
|
|
data = default(T);
|
|
var typeData = slice.Get(typeof(T)) as DataDictionary<T>;
|
|
if (typeData.ContainsKey(symbol))
|
|
{
|
|
data = typeData[symbol];
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Tries to get the data for the specified symbol and type
|
|
/// </summary>
|
|
/// <param name="slice">The slice</param>
|
|
/// <param name="type">The type of data we seek</param>
|
|
/// <param name="symbol">The symbol data is sought for</param>
|
|
/// <param name="data">The found data</param>
|
|
/// <returns>True if data was found for the specified type and symbol</returns>
|
|
public static bool TryGet(this Slice slice, Type type, Symbol symbol, out dynamic data)
|
|
{
|
|
data = null;
|
|
var typeData = slice.Get(type);
|
|
if (typeData.ContainsKey(symbol))
|
|
{
|
|
data = typeData[symbol];
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Converts the specified enumerable of decimals into a double array
|
|
/// </summary>
|
|
/// <param name="decimals">The enumerable of decimal</param>
|
|
/// <returns>Double array representing the enumerable of decimal</returns>
|
|
public static double[] ToDoubleArray(this IEnumerable<decimal> decimals)
|
|
{
|
|
return decimals.Select(x => (double) x).ToArray();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Loops through the specified slices and pushes the data into the consolidators. This can be used to
|
|
/// easily warm up indicators from a history call that returns slice objects.
|
|
/// </summary>
|
|
/// <param name="slices">The data to send into the consolidators, likely result of a history request</param>
|
|
/// <param name="consolidatorsBySymbol">Dictionary of consolidators keyed by symbol</param>
|
|
public static void PushThroughConsolidators(this IEnumerable<Slice> slices, Dictionary<Symbol, IDataConsolidator> consolidatorsBySymbol)
|
|
{
|
|
PushThroughConsolidators(slices, symbol =>
|
|
{
|
|
IDataConsolidator consolidator;
|
|
consolidatorsBySymbol.TryGetValue(symbol, out consolidator);
|
|
return consolidator;
|
|
});
|
|
}
|
|
|
|
/// <summary>
|
|
/// Loops through the specified slices and pushes the data into the consolidators. This can be used to
|
|
/// easily warm up indicators from a history call that returns slice objects.
|
|
/// </summary>
|
|
/// <param name="slices">The data to send into the consolidators, likely result of a history request</param>
|
|
/// <param name="consolidatorsProvider">Delegate that fetches the consolidators by a symbol</param>
|
|
public static void PushThroughConsolidators(this IEnumerable<Slice> slices, Func<Symbol, IDataConsolidator> consolidatorsProvider)
|
|
{
|
|
slices.PushThrough(data => consolidatorsProvider(data?.Symbol)?.Update(data));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Loops through the specified slices and pushes the data into the consolidators. This can be used to
|
|
/// easily warm up indicators from a history call that returns slice objects.
|
|
/// </summary>
|
|
/// <param name="slices">The data to send into the consolidators, likely result of a history request</param>
|
|
/// <param name="handler">Delegate handles each data piece from the slice</param>
|
|
/// <param name="dataType">Defines the type of the data that should be pushed</param>
|
|
public static void PushThrough(this IEnumerable<Slice> slices, Action<BaseData> handler, Type dataType = null)
|
|
{
|
|
if (dataType != null)
|
|
{
|
|
Func<Slice, IEnumerable<BaseData>> dataSelector = default;
|
|
if (dataType == typeof(QuoteBar))
|
|
{
|
|
dataSelector = slice => slice.QuoteBars.Values;
|
|
}
|
|
else if (dataType == typeof(Tick))
|
|
{
|
|
dataSelector = slice => slice.Ticks.Values.Select(x => x.Last());
|
|
}
|
|
else if (dataType == typeof(TradeBar))
|
|
{
|
|
dataSelector = slice => slice.Bars.Values;
|
|
}
|
|
else
|
|
{
|
|
dataSelector = slice => slice.Get(dataType).Values;
|
|
}
|
|
|
|
foreach (var slice in slices)
|
|
{
|
|
foreach (BaseData baseData in dataSelector(slice))
|
|
{
|
|
handler(baseData);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
foreach (var slice in slices)
|
|
{
|
|
foreach (var symbol in slice.Keys)
|
|
{
|
|
dynamic value;
|
|
if (!slice.TryGetValue(symbol, out value))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
var list = value as IList;
|
|
var data = (BaseData)(list != null ? list[list.Count - 1] : value);
|
|
|
|
handler(data);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|