/// <summary> /// Initializes a new instance of the <see cref="FineFundamentalFilteredUniverse"/> class /// </summary> /// <param name="universe">The universe to be filtered</param> /// <param name="fineSelector">The fine selection function</param> public FineFundamentalFilteredUniverse(Universe universe, PyObject fineSelector) : base(universe, universe.SelectSymbols) { var func = fineSelector.ConvertToDelegate <Func <IEnumerable <FineFundamental>, Symbol[]> >(); FineFundamentalUniverse = new FineFundamentalUniverse(universe.UniverseSettings, universe.SecurityInitializer, func); }
/// <summary> /// Initializes a new instance of the <see cref="FineFundamentalFilteredUniverse"/> class /// </summary> /// <param name="universe">The universe to be filtered</param> /// <param name="fineSelector">The fine selection function</param> public FineFundamentalFilteredUniverse(Universe universe, PyObject fineSelector) : base(universe, universe.SelectSymbols) { var func = fineSelector.ConvertToDelegate <Func <IEnumerable <FineFundamental>, Symbol[]> >(); FineFundamentalUniverse = new FineFundamentalUniverse(universe.UniverseSettings, func); FineFundamentalUniverse.SelectionChanged += (sender, args) => OnSelectionChanged(((SelectionEventArgs)args).CurrentSelection); }
/// <summary> /// Gets an enumerable of opened <see cref="OrderTicket"/> matching the specified <paramref name="filter"/> /// However, this method can be confused with the override that takes a Symbol as parameter. For this reason /// it first checks if it can convert the parameter into a symbol. If that conversion cannot be aplied it /// assumes the parameter is a Python function object and not a Python representation of a Symbol. /// </summary> /// <param name="filter">The Python function filter used to find the required order tickets</param> /// <returns>An enumerable of opened <see cref="OrderTicket"/> matching the specified <paramref name="filter"/></returns> public IEnumerable <OrderTicket> GetOpenOrderTickets(PyObject filter) { Symbol pythonSymbol; if (filter.TryConvert(out pythonSymbol)) { return(GetOpenOrderTickets(pythonSymbol)); } return(_orderProcessor.GetOpenOrderTickets(filter.ConvertToDelegate <Func <OrderTicket, bool> >())); }
/// <summary> /// Initializes a new instance of the <see cref="CustomUniverseSelectionModel"/> class /// </summary> /// <param name="securityType">The security type of the universe</param> /// <param name="name">A unique name for this universe</param> /// <param name="market">The market of the universe</param> /// <param name="selector">Function delegate that accepts a DateTime and returns a collection of string symbols</param> /// <param name="universeSettings">The settings used when adding symbols to the algorithm, specify null to use algorithm.UniverseSettings</param> public CustomUniverseSelectionModel(SecurityType securityType, string name, string market, PyObject selector, UniverseSettings universeSettings, TimeSpan interval) : this( securityType, name, market, selector.ConvertToDelegate <Func <DateTime, object> >().ConvertToUniverseSelectionStringDelegate(), universeSettings, interval ) { }
/// <summary> /// Gets open orders matching the specified filter. However, this method can be confused with the /// override that takes a Symbol as parameter. For this reason it first checks if it can convert /// the parameter into a symbol. If that conversion cannot be aplied it assumes the parameter is /// a Python function object and not a Python representation of a Symbol. /// </summary> /// <param name="filter">Python function object used to filter the orders</param> /// <returns>All filtered open orders this order provider currently holds</returns> public List <Order> GetOpenOrders(PyObject filter) { Symbol pythonSymbol; if (filter.TryConvert(out pythonSymbol)) { return(GetOpenOrders(pythonSymbol)); } Func <Order, bool> csharpFilter = filter.ConvertToDelegate <Func <Order, bool> >(); return(_orderProcessor.GetOpenOrders(x => csharpFilter(x))); }
/// <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 epected 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> public void 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); var config = new SubscriptionDataConfig(dataType, symbol, resolution, dataTimeZone, exchangeTimeZone, false, false, true, true, isFilteredSubscription: false); var selector = pySelector.ConvertToDelegate <Func <IEnumerable <IBaseData>, object[]> >(); AddUniverse(new FuncUniverse(config, universeSettings, SecurityInitializer, d => selector(d) .Select(x => x is Symbol ? (Symbol)x : QuantConnect.Symbol.Create((string)x, securityType, market)))); }
/// <summary> /// Constructor that takes as a parameter the security used to seed the price /// </summary> /// <param name="seedFunction">The seed function to use</param> public FuncSecuritySeeder(PyObject seedFunction) { var result = seedFunction.ConvertToDelegate <Func <Security, object> >(); _seedFunction = security => { var dataObject = result(security); var dataPoint = dataObject as BaseData; if (dataPoint != null) { return(new[] { dataPoint }); } return((IEnumerable <BaseData>)dataObject); }; }
/// <summary> /// Gets all orders matching the specified filter. /// </summary> /// <param name="filter">Python function object used to filter the orders</param> /// <returns>All orders this order provider currently holds by the specified filter</returns> public IEnumerable <Order> GetOrders(PyObject filter) { return(_orderProcessor.GetOrders(filter.ConvertToDelegate <Func <Order, bool> >())); }
/// <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> public void AddUniverse(SecurityType securityType, string name, Resolution resolution, string market, UniverseSettings universeSettings, PyObject pySelector) { var selector = pySelector.ConvertToDelegate <Func <DateTime, object[]> >(); AddUniverse(securityType, name, resolution, market, universeSettings, d => selector(d).Select(x => (string)x)); }
/// <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> public void AddUniverse(string name, PyObject pySelector) { var selector = pySelector.ConvertToDelegate <Func <DateTime, object[]> >(); AddUniverse(name, d => selector(d).Select(x => (string)x)); }
/// <summary> /// Python helper method to set the rebalancing function. /// This is required due to a python net limitation being able to use the base type constructor /// </summary> /// <param name="rebalancingFunc">For a given algorithm UTC DateTime returns the next expected rebalance time</param> protected void SetRebalancingFunc(PyObject rebalancingFunc) { _rebalancingFunc = rebalancingFunc.ConvertToDelegate <Func <DateTime, DateTime?> >(); }