Fix UniverseHistory empty results when selection returns different security type

Research/QuantBook.cs

@@ -940,15 +940,17 @@ private IEnumerable<BaseDataCollection> RunUniverseSelection(Universe universe,
             var history = History(universe, start, endDate);
 
             HashSet<Symbol> filteredSymbols = null;
+            SecurityType? filteredSecurityType = null;
             Func<BaseDataCollection, BaseDataCollection> processDataPoint = dataPoint =>
             {
                 var utcTime = dataPoint.EndTime.ConvertToUtc(universe.Configuration.ExchangeTimeZone);
                 var selection = universe.SelectSymbols(utcTime, dataPoint);
                 if (!ReferenceEquals(selection, Universe.Unchanged))
                 {
                     filteredSymbols = selection.ToHashSet();
+                    filteredSecurityType = filteredSymbols.FirstOrDefault()?.ID.SecurityType;
                 }
-                dataPoint.Data = dataPoint.Data.Where(x => filteredSymbols == null || filteredSymbols.Contains(x.Symbol)).ToList();
+                dataPoint.Data = FilterUniverseData(dataPoint.Data, filteredSymbols, filteredSecurityType);
                 return dataPoint;
             };
 
@@ -957,6 +959,19 @@ private IEnumerable<BaseDataCollection> RunUniverseSelection(Universe universe,
             return PerformSelection<BaseDataCollection, BaseDataCollection>(history, processDataPoint, getTime, start, endDate, dateRule);
         }
 
+        private static List<BaseData> FilterUniverseData(List<BaseData> data, HashSet<Symbol> filteredSymbols, SecurityType? filteredSecurityType)
+        {
+            return data.Where(x =>
+                filteredSymbols == null ||
+                filteredSymbols.Contains(x.Symbol) ||
+                (filteredSecurityType.HasValue && x.Symbol.SecurityType != filteredSecurityType.Value &&
+                 filteredSymbols.Any(s =>
+                     CurrencyPairUtil.TryDecomposeCurrencyPair(s, out var baseCurrency, out var quoteCurrency) &&
+                     (x.Symbol.Value.Equals(baseCurrency, StringComparison.OrdinalIgnoreCase) ||
+                      x.Symbol.Value.Equals(quoteCurrency, StringComparison.OrdinalIgnoreCase))))
+            ).ToList();
+        }
+
         /// <summary>
         /// Converts a pandas.Series into a <see cref="SortedDictionary{DateTime, Double}"/>
         /// </summary>

Tests/Research/QuantBookSelectionTests.cs

@@ -15,13 +15,17 @@
 
 using System;
 using System.Linq;
+using System.Reflection;
 using Python.Runtime;
 using NUnit.Framework;
 using QuantConnect.Research;
 using System.Collections.Generic;
+using QuantConnect.Data;
 using QuantConnect.Data.Fundamental;
+using QuantConnect.Data.Market;
 using QuantConnect.Data.UniverseSelection;
 using QuantConnect.Scheduling;
+using QuantConnect.Util;
 
 namespace QuantConnect.Tests.Research
 {
@@ -824,6 +828,25 @@ def getUniverseHistory(self, qb, start, end, symbol, flatten):
             }
         }
 
+        [Test]
+        public void FilterUniverseDataFallsBackToCurrencyPairMatchingWhenSecurityTypesDiffer()
+        {
+            var eurBase = new Symbol(SecurityIdentifier.GenerateBase(typeof(Fundamental), "EUR", Market.USA), "EUR");
+            var gbpBase = new Symbol(SecurityIdentifier.GenerateBase(typeof(Fundamental), "GBP", Market.USA), "GBP");
+            var eurUsd = Symbol.Create("EURUSD", SecurityType.Forex, Market.Oanda);
+
+            // selection returns Forex — security type differs from Base data symbols
+            var filteredSymbols = new HashSet<Symbol> { eurUsd };
+            var data = new List<BaseData> { new Tick { Symbol = eurBase }, new Tick { Symbol = gbpBase } };
+
+            var filterMethod = typeof(QuantBook).GetMethod("FilterUniverseData", BindingFlags.NonPublic | BindingFlags.Static);
+            var result = (List<BaseData>)filterMethod.Invoke(null, new object[] { data, filteredSymbols, (SecurityType?)eurUsd.SecurityType });
+
+            // EUR matches EURUSD base currency, GBP matches neither
+            Assert.AreEqual(1, result.Count);
+            Assert.AreEqual(eurBase, result[0].Symbol);
+        }
+
         [Test]
         public void PerformSelectionDoesNotSkipDataPointWhenPreviousDataPointIsYielded()
         {
@@ -875,7 +898,7 @@ private static string GetBaseImplementation(int expectedCount, string identation
 .Replace("{identation}", identation, StringComparison.InvariantCulture);
         }
 
-        private class QuantBookTestClass: QuantBook
+        private class QuantBookTestClass : QuantBook
         {
             public static IEnumerable<BaseDataCollection> PerformSelection(IEnumerable<BaseDataCollection> history, DateTime start, DateTime end, IDateRule dateRule)
             {