Support Count and Python len() on user-facing lazy enumerables

Common/Data/SubscriptionManager.cs

@@ -47,7 +47,7 @@ public class SubscriptionManager
         ///     Returns an IEnumerable of Subscriptions
         /// </summary>
         /// <remarks>Will not return internal subscriptions</remarks>
-        public IEnumerable<SubscriptionDataConfig> Subscriptions => _subscriptionManager.SubscriptionManagerSubscriptions.Where(config => !config.IsInternalFeed);
+        public IEnumerable<SubscriptionDataConfig> Subscriptions => _subscriptionManager.SubscriptionManagerSubscriptions.Where(config => !config.IsInternalFeed).Memoize();
 
         /// <summary>
         ///     The different <see cref="TickType" /> each <see cref="SecurityType" /> supports

Common/Securities/Cash.cs

@@ -23,6 +23,7 @@
 using QuantConnect.Interfaces;
 using QuantConnect.Logging;
 using QuantConnect.Securities.CurrencyConversion;
+using QuantConnect.Util;
 
 namespace QuantConnect.Securities
 {
@@ -52,7 +53,7 @@ public class Cash
         /// If this cash represents the account currency, then an empty enumerable is returned.
         /// </summary>
         public IEnumerable<Symbol> SecuritySymbols => CurrencyConversion.ConversionRateSecurities.Any()
-            ? CurrencyConversion.ConversionRateSecurities.Select(x => x.Symbol)
+            ? CurrencyConversion.ConversionRateSecurities.Select(x => x.Symbol).Memoize()
             // we do this only because Newtonsoft.Json complains about empty enumerables
             : new List<Symbol>(0);
 

Common/Securities/CurrencyConversion/ConstantCurrencyConversion.cs

@@ -17,6 +17,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using QuantConnect.Util;
 
 namespace QuantConnect.Securities.CurrencyConversion
 {
@@ -65,7 +66,7 @@ public decimal ConversionRate
         /// <summary>
         /// The securities which the conversion rate is based on
         /// </summary>
-        public IEnumerable<Security> ConversionRateSecurities => Enumerable.Empty<Security>();
+        public IEnumerable<Security> ConversionRateSecurities => Enumerable.Empty<Security>().Memoize();
 
         /// <summary>
         /// Initializes a new instance of the <see cref="ConstantCurrencyConversion"/> class.

Common/Securities/CurrencyConversion/SecurityCurrencyConversion.cs

@@ -134,7 +134,7 @@ public decimal ConversionRate
         /// <summary>
         /// The securities which the conversion rate is based on
         /// </summary>
-        public IEnumerable<Security> ConversionRateSecurities => _steps.Select(step => step.RateSecurity);
+        public IEnumerable<Security> ConversionRateSecurities => _steps.Select(step => step.RateSecurity).Memoize();
 
         /// <summary>
         /// Initializes a new instance of the <see cref="SecurityCurrencyConversion"/> class.

Common/Securities/SecurityTransactionManager.cs

@@ -20,6 +20,7 @@
 using QuantConnect.Interfaces;
 using QuantConnect.Logging;
 using QuantConnect.Orders;
+using QuantConnect.Util;
 using Python.Runtime;
 
 namespace QuantConnect.Securities
@@ -255,7 +256,7 @@ public List<OrderTicket> CancelOpenOrders()
             }
 
             var cancelledOrders = new List<OrderTicket>();
-            foreach (var ticket in GetOpenOrderTickets())
+            foreach (var ticket in GetOpenOrderTickets(null, memoize: false))
             {
                 ticket.Cancel(Messages.SecurityTransactionManager.OrderCanceledByCancelOpenOrders(_algorithm.UtcTime));
                 cancelledOrders.Add(ticket);
@@ -277,7 +278,7 @@ public List<OrderTicket> CancelOpenOrders(Symbol symbol, string tag = null)
             }
 
             var cancelledOrders = new List<OrderTicket>();
-            foreach (var ticket in GetOpenOrderTickets(x => x.Symbol == symbol))
+            foreach (var ticket in GetOpenOrderTickets(x => x.Symbol == symbol, memoize: false))
             {
                 ticket.Cancel(tag);
                 cancelledOrders.Add(ticket);
@@ -302,7 +303,7 @@ public OrderTicket RemoveOrder(int orderId, string tag = null)
         /// <returns>An enumerable of <see cref="OrderTicket"/> matching the specified <paramref name="filter"/></returns>
         public IEnumerable<OrderTicket> GetOrderTickets(Func<OrderTicket, bool> filter = null)
         {
-            return _orderProcessor.GetOrderTickets(filter ?? (x => true));
+            return GetOrderTickets(filter, memoize: true);
         }
 
         /// <summary>
@@ -312,7 +313,21 @@ public IEnumerable<OrderTicket> GetOrderTickets(Func<OrderTicket, bool> filter =
         /// <returns>An enumerable of <see cref="OrderTicket"/> matching the specified <paramref name="filter"/></returns>
         public IEnumerable<OrderTicket> GetOrderTickets(PyObject filter)
         {
-            return _orderProcessor.GetOrderTickets(filter.SafeAs<Func<OrderTicket, bool>>());
+            return GetOrderTickets(filter.SafeAs<Func<OrderTicket, bool>>(), memoize: true);
+        }
+
+        /// <summary>
+        /// Gets an enumerable of <see cref="OrderTicket"/> matching the specified <paramref name="filter"/>
+        /// </summary>
+        /// <param name="filter">The filter predicate used to find the required order tickets, null matches all</param>
+        /// <param name="memoize">True for enumerables handed back to user algorithms, which may enumerate them
+        /// multiple times. Engine paths that enumerate a single time should pass false, since memoization there
+        /// only adds allocation and locking overhead</param>
+        /// <returns>An enumerable of <see cref="OrderTicket"/> matching the specified <paramref name="filter"/></returns>
+        private IEnumerable<OrderTicket> GetOrderTickets(Func<OrderTicket, bool> filter, bool memoize)
+        {
+            var tickets = _orderProcessor.GetOrderTickets(filter ?? (x => true));
+            return memoize ? tickets.Memoize() : tickets;
         }
 
         /// <summary>
@@ -332,7 +347,7 @@ public IEnumerable<OrderTicket> GetOpenOrderTickets(Symbol symbol)
         /// <returns>An enumerable of opened <see cref="OrderTicket"/> matching the specified <paramref name="filter"/></returns>
         public IEnumerable<OrderTicket> GetOpenOrderTickets(Func<OrderTicket, bool> filter = null)
         {
-            return _orderProcessor.GetOpenOrderTickets(filter ?? (x => true));
+            return GetOpenOrderTickets(filter, memoize: true);
         }
 
         /// <summary>
@@ -350,7 +365,21 @@ public IEnumerable<OrderTicket> GetOpenOrderTickets(PyObject filter)
             {
                 return GetOpenOrderTickets(pythonSymbol);
             }
-            return _orderProcessor.GetOpenOrderTickets(filter.SafeAs<Func<OrderTicket, bool>>());
+            return GetOpenOrderTickets(filter.SafeAs<Func<OrderTicket, bool>>(), memoize: true);
+        }
+
+        /// <summary>
+        /// Gets an enumerable of opened <see cref="OrderTicket"/> matching the specified <paramref name="filter"/>
+        /// </summary>
+        /// <param name="filter">The filter predicate used to find the required order tickets, null matches all</param>
+        /// <param name="memoize">True for enumerables handed back to user algorithms, which may enumerate them
+        /// multiple times. Engine paths that enumerate a single time should pass false, since memoization there
+        /// only adds allocation and locking overhead</param>
+        /// <returns>An enumerable of opened <see cref="OrderTicket"/> matching the specified <paramref name="filter"/></returns>
+        private IEnumerable<OrderTicket> GetOpenOrderTickets(Func<OrderTicket, bool> filter, bool memoize)
+        {
+            var tickets = _orderProcessor.GetOpenOrderTickets(filter ?? (x => true));
+            return memoize ? tickets.Memoize() : tickets;
         }
 
         /// <summary>
@@ -360,7 +389,7 @@ public IEnumerable<OrderTicket> GetOpenOrderTickets(PyObject filter)
         /// <returns>Total quantity that hasn't been filled yet for all orders that were not filtered</returns>
         public decimal GetOpenOrdersRemainingQuantity(Func<OrderTicket, bool> filter = null)
         {
-            return GetOpenOrderTickets(filter)
+            return GetOpenOrderTickets(filter, memoize: false)
                 .Aggregate(0m, (d, t) => d + t.QuantityRemaining);
         }
 
@@ -380,8 +409,7 @@ public decimal GetOpenOrdersRemainingQuantity(PyObject filter)
                 return GetOpenOrdersRemainingQuantity(pythonSymbol);
             }
 
-            return GetOpenOrderTickets(filter)
-                .Aggregate(0m, (d, t) => d + t.QuantityRemaining);
+            return GetOpenOrdersRemainingQuantity(filter.SafeAs<Func<OrderTicket, bool>>());
         }
 
         /// <summary>
@@ -512,7 +540,7 @@ public List<Order> GetOrdersByBrokerageId(string brokerageId)
         /// <returns>All orders this order provider currently holds by the specified filter</returns>
         public IEnumerable<Order> GetOrders(Func<Order, bool> filter = null)
         {
-            return _orderProcessor.GetOrders(filter ?? (x => true));
+            return _orderProcessor.GetOrders(filter ?? (x => true)).Memoize();
         }
 
         /// <summary>
@@ -522,7 +550,7 @@ public IEnumerable<Order> GetOrders(Func<Order, bool> filter = null)
         /// <returns>All orders this order provider currently holds by the specified filter</returns>
         public IEnumerable<Order> GetOrders(PyObject filter)
         {
-            return _orderProcessor.GetOrders(filter.SafeAs<Func<Order, bool>>());
+            return _orderProcessor.GetOrders(filter.SafeAs<Func<Order, bool>>()).Memoize();
         }
 
         /// <summary>

Tests/Common/Data/SubscriptionManagerTests.cs

@@ -21,13 +21,15 @@
 using NodaTime;
 using NUnit.Framework;
 using Python.Runtime;
+using QuantConnect.Algorithm;
 using QuantConnect.Data;
 using QuantConnect.Data.Consolidators;
 using QuantConnect.Data.Market;
 using QuantConnect.Data.UniverseSelection;
 using QuantConnect.Logging;
 using QuantConnect.Statistics;
 using QuantConnect.Tests.Engine.DataFeeds;
+using QuantConnect.Util;
 
 namespace QuantConnect.Tests.Common.Data
 {
@@ -53,6 +55,23 @@ public void GetsSubscriptionDataTypesLowResolution(SecurityType securityType, Re
             }
         }
 
+        [Test]
+        public void SubscriptionsAreMemoizedExposingCount()
+        {
+            var algorithm = new QCAlgorithm();
+            algorithm.SubscriptionManager.SetDataManager(new DataManagerStub(algorithm));
+            algorithm.AddEquity("SPY");
+            algorithm.AddForex("EURUSD");
+
+            var subscriptions = algorithm.SubscriptionManager.Subscriptions;
+
+            // memoized so it exposes a Count property, which also enables len() in Python through Python.NET
+            Assert.IsInstanceOf<MemoizingEnumerable<SubscriptionDataConfig>>(subscriptions);
+            var memoizedSubscriptions = (MemoizingEnumerable<SubscriptionDataConfig>)subscriptions;
+            Assert.Greater(memoizedSubscriptions.Count, 0);
+            Assert.AreEqual(subscriptions.Count(), memoizedSubscriptions.Count);
+        }
+
         [Test]
         [TestCase(SecurityType.Base, Resolution.Minute, typeof(TradeBar), TickType.Trade)]
         [TestCase(SecurityType.Base, Resolution.Tick, typeof(Tick), TickType.Trade)]

Tests/Common/Securities/CashTests.cs

@@ -28,6 +28,7 @@
 using QuantConnect.Securities.CurrencyConversion;
 using QuantConnect.Tests.Common.Data.UniverseSelection;
 using QuantConnect.Tests.Engine.DataFeeds;
+using QuantConnect.Util;
 
 namespace QuantConnect.Tests.Common.Securities
 {
@@ -115,6 +116,40 @@ public void EnsureCurrencyDataFeedAddsSubscription()
             Assert.AreEqual(1, securities.Values.Count(x => x.Symbol == Symbols.USDJPY));
         }
 
+        [Test]
+        public void SecuritySymbolsAreMemoizedExposingCount()
+        {
+            const int quantity = 100;
+            const decimal conversionRate = 1 / 100m;
+            var cash = new Cash("JPY", quantity, conversionRate);
+            var cashBook = new CashBook();
+            cashBook.Add("JPY", cash);
+            var subscriptions = new SubscriptionManager(NullTimeKeeper.Instance);
+            var dataManager = new DataManagerStub(TimeKeeper);
+            subscriptions.SetDataManager(dataManager);
+            var abcConfig = subscriptions.Add(Symbols.SPY, Resolution.Minute, TimeZone, TimeZone);
+            var securities = new SecurityManager(TimeKeeper);
+
+            securities.Add(
+                Symbols.SPY,
+                new Security(
+                    SecurityExchangeHours,
+                    abcConfig,
+                    new Cash(Currencies.USD, 0, 1m),
+                    SymbolProperties.GetDefault(cashBook.AccountCurrency),
+                    cashBook,
+                    RegisteredSecurityDataTypesProvider.Null,
+                    new SecurityCache()));
+            cash.EnsureCurrencyDataFeed(securities, subscriptions, MarketMap, SecurityChanges.None, dataManager.SecurityService, cashBook.AccountCurrency);
+
+            var securitySymbols = cash.SecuritySymbols;
+
+            // memoized so it exposes a Count property, which also enables len() in Python through Python.NET
+            Assert.IsInstanceOf<MemoizingEnumerable<Symbol>>(securitySymbols);
+            Assert.AreEqual(1, ((MemoizingEnumerable<Symbol>)securitySymbols).Count);
+            Assert.AreEqual(Symbols.USDJPY, securitySymbols.Single());
+        }
+
         [Test]
         public void EnsureCurrencyDataFeedChecksSecurityChangesForSecurity()
         {

Tests/Common/Securities/CurrencyConversion/SecurityCurrencyConversionTests.cs

@@ -22,6 +22,7 @@
 using QuantConnect.Securities;
 using QuantConnect.Securities.CurrencyConversion;
 using QuantConnect.Tests.Engine.DataFeeds;
+using QuantConnect.Util;
 
 namespace QuantConnect.Tests.Common.Securities.CurrencyConversion
 {
@@ -91,6 +92,34 @@ public void LinearSearchFindsTwoLegConversions()
             Assert.AreEqual(Symbols.EURUSD, securities[1].Symbol);
         }
 
+        [Test]
+        public void ConversionRateSecuritiesAreMemoizedExposingCount()
+        {
+            var currencyConversion = SecurityCurrencyConversion.LinearSearch(
+                "BTC",
+                "EUR",
+                new List<Security>(0),
+                new List<Symbol> { Symbols.BTCUSD, Symbols.EURUSD },
+                CreateSecurity);
+
+            var securities = currencyConversion.ConversionRateSecurities;
+
+            // memoized so it exposes a Count property, which also enables len() in Python through Python.NET
+            Assert.IsInstanceOf<MemoizingEnumerable<Security>>(securities);
+            Assert.AreEqual(2, ((MemoizingEnumerable<Security>)securities).Count);
+        }
+
+        [Test]
+        public void ConstantConversionRateSecuritiesAreMemoizedExposingCount()
+        {
+            var currencyConversion = new ConstantCurrencyConversion("EUR", "USD", 1.2m);
+
+            var securities = currencyConversion.ConversionRateSecurities;
+
+            Assert.IsInstanceOf<MemoizingEnumerable<Security>>(securities);
+            Assert.AreEqual(0, ((MemoizingEnumerable<Security>)securities).Count);
+        }
+
         [Test]
         public void LinearSearchPrefersExistingSecuritiesOverNewOnesOneLeg()
         {