/// <summary>
/// Gets the symbols/string from a PyObject
/// </summary>
/// <param name="pyObject">PyObject containing symbols</param>
/// <returns>List of symbols</returns>
public List <Symbol> GetSymbolsFromPyObject(PyObject pyObject)
{
using (Py.GIL())
{
// If not a PyList, convert it into one
if (!PyList.IsListType(pyObject))
{
var tmp = new PyList();
tmp.Append(pyObject);
pyObject = tmp;
}
var symbols = new List <Symbol>();
foreach (PyObject item in pyObject)
{
var symbol = (Symbol)item.AsManagedObject(typeof(Symbol));
if (string.IsNullOrWhiteSpace(symbol.Value))
{
continue;
}
symbols.Add(symbol);
}
return(symbols.Count == 0 ? null : symbols);
}
}
/// <summary>
/// Get list of symbols from a PyObject
/// </summary>
/// <param name="pyObject">PyObject containing a list of tickers</param>
/// <returns>List of Symbol</returns>
private List <Symbol> GetSymbolsFromPyObject(PyObject pyObject, bool isEquity = false)
{
using (Py.GIL())
{
// If not a PyList, convert it into one
if (!PyList.IsListType(pyObject))
{
var tmp = new PyList();
tmp.Append(pyObject);
pyObject = tmp;
}
var symbols = new List <Symbol>();
foreach (PyObject item in pyObject)
{
var symbol = (Symbol)item.AsManagedObject(typeof(Symbol));
if (isEquity && string.IsNullOrWhiteSpace(symbol.Value))
{
var ticker = (string)item.AsManagedObject(typeof(string));
symbol = new Symbol(SecurityIdentifier.GenerateEquity(ticker, Market.USA), ticker);
}
symbols.Add(symbol);
}
return(symbols.Count == 0 || string.IsNullOrEmpty(symbols.First().Value) ? null : symbols);
}
}
/// <summary>
/// Get fundamental data from given symbols
/// </summary>
/// <param name="pyObject">The symbols to retrieve fundamental data for</param>
/// <param name="selector">Selects a value from the Fundamental data to filter the request output</param>
/// <param name="start">The start date of selected data</param>
/// <param name="end">The end date of selected data</param>
/// <returns></returns>
public PyObject GetFundamental(PyObject tickers, string selector, DateTime?start = null, DateTime?end = null)
{
if (string.IsNullOrWhiteSpace(selector))
{
return("Invalid selector. Cannot be None, empty or consist only of white-space characters".ToPython());
}
using (Py.GIL())
{
// If tickers are not a PyList, we create one
if (!PyList.IsListType(tickers))
{
var tmp = new PyList();
tmp.Append(tickers);
tickers = tmp;
}
var list = new List <Tuple <Symbol, DateTime, object> >();
foreach (var ticker in tickers)
{
var symbol = QuantConnect.Symbol.Create(ticker.ToString(), SecurityType.Equity, Market.USA);
var dir = new DirectoryInfo(Path.Combine(Globals.DataFolder, "equity", symbol.ID.Market, "fundamental", "fine", symbol.Value.ToLowerInvariant()));
if (!dir.Exists)
{
continue;
}
var config = new SubscriptionDataConfig(typeof(FineFundamental), symbol, Resolution.Daily, TimeZones.NewYork, TimeZones.NewYork, false, false, false);
foreach (var fileName in dir.EnumerateFiles())
{
var date = DateTime.ParseExact(fileName.Name.Substring(0, 8), DateFormat.EightCharacter, CultureInfo.InvariantCulture);
if (date < start || date > end)
{
continue;
}
var factory = new TextSubscriptionDataSourceReader(_dataCacheProvider, config, date, false);
var source = new SubscriptionDataSource(fileName.FullName, SubscriptionTransportMedium.LocalFile);
var value = factory.Read(source).Select(x => GetPropertyValue(x, selector)).First();
list.Add(Tuple.Create(symbol, date, value));
}
}
var data = new PyDict();
foreach (var item in list.GroupBy(x => x.Item1))
{
var index = item.Select(x => x.Item2);
data.SetItem(item.Key, _pandas.Series(item.Select(x => x.Item3).ToList(), index));
}
return(_pandas.DataFrame(data));
}
}
/// <summary>
/// Convert Python input to a list of Symbols
/// </summary>
/// <param name="input">Object with the desired property</param>
/// <returns>List of Symbols</returns>
public static IEnumerable <Symbol> ConvertToSymbols(PyObject input)
{
List <Symbol> symbolsList;
Symbol symbol;
using (Py.GIL())
{
// Handle the possible types of conversions
if (PyList.IsListType(input))
{
List <string> symbolsStringList;
//Check if an entry in the list is a string type, if so then try and convert the whole list
if (PyString.IsStringType(input[0]) && input.TryConvert(out symbolsStringList))
{
symbolsList = new List <Symbol>();
foreach (var stringSymbol in symbolsStringList)
{
symbol = QuantConnect.Symbol.Create(stringSymbol, SecurityType.Equity, Market.USA);
symbolsList.Add(symbol);
}
}
//Try converting it to list of symbols, if it fails throw exception
else if (!input.TryConvert(out symbolsList))
{
throw new ArgumentException($"Cannot convert list {input.Repr()} to symbols");
}
}
else
{
//Check if its a single string, and try and convert it
string symbolString;
if (PyString.IsStringType(input) && input.TryConvert(out symbolString))
{
symbol = QuantConnect.Symbol.Create(symbolString, SecurityType.Equity, Market.USA);
symbolsList = new List <Symbol> {
symbol
};
}
else if (input.TryConvert(out symbol))
{
symbolsList = new List <Symbol> {
symbol
};
}
else
{
throw new ArgumentException($"Cannot convert object {input.Repr()} to symbol");
}
}
}
return(symbolsList);
}
public void TestListIsListType()
{
var s = new PyList();
Assert.True(PyList.IsListType(s));
}
public void TestStringIsListType()
{
var s = new PyString("foo");
Assert.False(PyList.IsListType(s));
}
