Feat: cache PrimaryExchange for Equities (#185)

* feat: PrimaryExchangeService
test:feat: test primary exchange service

* fix: if primary exchange is null

* test:feat: LeanPrimaryExchangeShouldMachIB

* remove: not used cache in EquityPrimaryExchangeService

* remove: primaryExchange service

* refactor: GetPrimaryExchange simplify

* refactor: GetPrimaryExchange + xml description

Author: Romazes

QuantConnect.InteractiveBrokersBrokerage.Tests/InteractiveBrokersBrokerageAdditionalTests.cs

@@ -14,6 +14,7 @@
 */
 
 using System;
+using System.Text;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Globalization;
@@ -1175,6 +1176,66 @@ private Contract CreateContract(Symbol symbol)
             return contract;
         }
 
+        [Test, Explicit("Long-running test (~10 minutes). Compares LEAN and IB API primary exchanges for up to 1000 equity symbols.")]
+        public void GetEquityPrimaryExchangeShouldMatchBetweenLeanAndIB()
+        {
+            using var ib = new InteractiveBrokersBrokerage(new QCAlgorithm(), new OrderProvider(), new SecurityProvider());
+            ib.Connect();
+
+            var tickers = QuantConnect.Algorithm.CSharp.StressSymbols.StockSymbols.ToList();
+
+            var totalCount = default(int);
+            var equalCount = default(int);
+
+            var logBuilder = new StringBuilder($"***** GetEquityPrimaryExchange Test ({tickers.Count} tickers) *****");
+            var logBuilder2 = new StringBuilder("***** MissMatched Symbols *****");
+
+            foreach (var ticker in tickers)
+            {
+                totalCount++;
+
+                var symbol = Symbol.Create(ticker, SecurityType.Equity, Market.USA);
+
+                var contract = CreateContract(symbol);
+
+                var leanPrimaryExchange = ib.GetPrimaryExchange(contract, symbol);
+
+                var ibPrimaryExchange = ib.GetContractDetails(contract, symbol.Value)?.Contract.PrimaryExch;
+
+                if (ibPrimaryExchange == null)
+                {
+                    totalCount--;
+                    logBuilder.AppendLine($"[SKIP] Contract not found for {symbol}");
+                    continue;
+                }
+
+                if (totalCount == 1000)
+                {
+                    logBuilder.AppendLine("Symbol processing limit reached (1000). Stopping test.");
+                    break;
+                }
+
+                Assert.IsNotNull(leanPrimaryExchange);
+
+                bool isEqual = string.Equals(leanPrimaryExchange, ibPrimaryExchange, StringComparison.InvariantCultureIgnoreCase);
+                if (isEqual)
+                {
+                    logBuilder.AppendLine($"[RESULT] {symbol.Value} | LEAN = {leanPrimaryExchange} | IB API = {ibPrimaryExchange} | Match = {isEqual}");
+                    equalCount++;
+                }
+                else
+                {
+                    logBuilder2.AppendLine($"[RESULT] {symbol.Value} | LEAN = {leanPrimaryExchange} | IB API = {ibPrimaryExchange} | Match = {isEqual}");
+                }
+            }
+
+            logBuilder.AppendLine("----- Test Summary -----");
+            logBuilder.AppendLine($"Processed: {totalCount} | Matches: {equalCount} | Mismatches: {totalCount - equalCount}");
+
+            Log.Trace(logBuilder.ToString());
+            Log.Trace(logBuilder2.ToString());
+        }
+
         private List<BaseData> GetHistory(
             Symbol symbol,
             Resolution resolution,

QuantConnect.InteractiveBrokersBrokerage/InteractiveBrokersBrokerage.cs

@@ -207,6 +207,11 @@ public sealed class InteractiveBrokersBrokerage : Brokerage, IDataQueueHandler,
 
         private static readonly SymbolPropertiesDatabase _symbolPropertiesDatabase = SymbolPropertiesDatabase.FromDataFolder();
 
+        /// <summary>
+        /// Provides primary exchange data based on LEAN map files.
+        /// </summary>
+        private MapFilePrimaryExchangeProvider _exchangeProvider;
+
         // exchange time zones by symbol
         private readonly Dictionary<Symbol, DateTimeZone> _symbolExchangeTimeZones = new Dictionary<Symbol, DateTimeZone>();
 
@@ -1374,6 +1379,7 @@ private void Initialize(
 
             _symbolMapper = new InteractiveBrokersSymbolMapper(_mapFileProvider);
             _contractSpecificationService = new(GetContractDetails);
+            _exchangeProvider = new MapFilePrimaryExchangeProvider(_mapFileProvider);
 
             _subscriptionManager = new EventBasedDataQueueHandlerSubscriptionManager();
             _subscriptionManager.SubscribeImpl += (s, t) => Subscribe(s);
@@ -1615,24 +1621,37 @@ public static string GetContractDescription(Contract contract)
             return $"{contract} {contract.PrimaryExch ?? string.Empty} {contract.LastTradeDateOrContractMonth.ToStringInvariant()} {contract.Strike.ToStringInvariant()} {contract.Right}";
         }
 
-        private string GetPrimaryExchange(Contract contract, Symbol symbol)
+        /// <summary>
+        /// Retrieves the primary exchange for a given symbol.
+        /// </summary>
+        /// <param name="contract">The IB <see cref="Contract"/> object containing contract details.</param>
+        /// <param name="symbol">The Lean <see cref="Symbol"/> object representing the security.</param>
+        /// <returns>
+        /// The name of the primary exchange as a string.  
+        /// If the market is USA and Lean provides an exchange, that value is returned.  
+        /// Otherwise, falls back to the IB contract's <c>PrimaryExch</c> field.  
+        /// Returns <c>null</c> if no exchange information is available.
+        /// </returns>
+        internal string GetPrimaryExchange(Contract contract, Symbol symbol)
         {
-            var details = GetContractDetails(contract, symbol.Value);
-            if (details == null)
+            if (symbol.ID.Market.Equals(Market.USA, StringComparison.InvariantCultureIgnoreCase))
             {
-                // we were unable to find the contract details
-                return null;
+                var leanExchange = _exchangeProvider.GetPrimaryExchange(symbol.ID)?.Name;
+                if (!string.IsNullOrEmpty(leanExchange))
+                {
+                    return leanExchange;
+                }
             }
 
-            return details.Contract.PrimaryExch;
+            return GetContractDetails(contract, symbol.Value)?.Contract.PrimaryExch;
         }
 
         /// <summary>
         /// Will return and cache the IB contract details for the requested contract
         /// </summary>
         /// <param name="contract">The target contract</param>
         /// <param name="ticker">The associated Lean ticker. Just used for logging, can be provided empty</param>
-        private ContractDetails GetContractDetails(Contract contract, string ticker, bool failIfNotFound = true)
+        internal ContractDetails GetContractDetails(Contract contract, string ticker, bool failIfNotFound = true)
         {
             if (contract.SecType != null && _contractDetails.TryGetValue(GetUniqueKey(contract), out var details))
             {