static IList <IOptionDefinition> ResolveFlagOptionLabels( ICommandDefinition selectedCommand, string argument) { if (OptionSymbol.CanBeFullForm(argument)) { return(selectedCommand.GetRegisteredOptions() .Where(o => o.Type == OptionType.Flag && o.IsMatch(argument)) .ToArray()); } if (OptionSymbol.CanBeAbbreviationForm(argument)) { string[] flagArguments = SplitAbbrArgument(argument); if (flagArguments.HasDuplication(StringComparer.OrdinalIgnoreCase)) { throw new ArgParsingException(ArgsParsingErrorCode.DuplicateFlagsInArgs, argument); } IOptionDefinition[] resolvedDefinitions = selectedCommand.GetRegisteredOptions() .Where(o => o.Type == OptionType.Flag && flagArguments.Any(o.IsMatch)) .ToArray(); return(resolvedDefinitions.Length != flagArguments.Length ? Array.Empty <IOptionDefinition>() : resolvedDefinitions); } return(Array.Empty <IOptionDefinition>()); }
/// <summary> /// Check for delistings and emit them into the aux data queue /// </summary> private void CheckForDelisting(DateTime date) { DateTime delistingDate; switch (_config.Symbol.ID.SecurityType) { case SecurityType.Future: delistingDate = _config.Symbol.ID.Date; break; case SecurityType.Option: delistingDate = OptionSymbol.GetLastDayOfTrading(_config.Symbol); break; default: delistingDate = _mapFile.DelistingDate; break; } if (!_delistedWarning && date >= delistingDate) { _delistedWarning = true; var price = _previous != null ? _previous.Price : 0; _auxiliaryData.Enqueue(new Delisting(_config.Symbol, date, price, DelistingType.Warning)); } else if (!_delisted && date > delistingDate) { _delisted = true; var price = _previous != null ? _previous.Price : 0; // delisted at EOD _auxiliaryData.Enqueue(new Delisting(_config.Symbol, delistingDate.AddDays(1), price, DelistingType.Delisted)); } }
public void TestIfFridayLastTradingDayIsHolidaysThenMoveToPreviousThursday() { var saturdayAfterGoodFriday = new DateTime(2014, 04, 19); var thursdayBeforeGoodFriday = saturdayAfterGoodFriday.AddDays(-2); var symbol = Symbol.CreateOption("SPY", Market.USA, OptionStyle.American, OptionRight.Call, 200, saturdayAfterGoodFriday); Assert.AreEqual(thursdayBeforeGoodFriday, OptionSymbol.GetLastDayOfTrading(symbol)); }
// // Get ATM call and put // public virtual void get_contracts(Slice slice) { LogCust("called get contracts"); foreach (var kvp in slice.OptionChains) { if (kvp.Key != this.option_symbol) { continue; } var chain = kvp.Value; var spot_price = chain.Underlying.Price; // self.Log("spot_price {}" .format(spot_price)) // prefer to do in steps, rather than a nested sorted // 1. get furthest expiry var contracts_by_T = chain.OrderByDescending(x => x.Expiry).ToList(); if (!(contracts_by_T.Count > 0)) { return; } this.expiry = contracts_by_T[0].Expiry.Date; var weeklySymbol = QuantConnect.Symbol.CreateOption("SPY", Market.USA, OptionStyle.American, OptionRight.Call, 200, this.expiry); //var monthlysymbol = Symbol.CreateOption("SPY", Market.USA, OptionStyle.American, OptionRight.Call, 200, new DateTime(2020, 04, 17)); //Assert.True(OptionSymbol.IsWeekly(weeklySymbol)); //Assert.False(OptionSymbol.IsWeekly(monthlysymbol)); //Assert.AreEqual(new DateTime(2020, 04, 17)/*Friday*/, OptionSymbol.GetLastDayOfTrading(monthlysymbol)); //Good Friday on 10th so should be 9th //Assert.AreEqual(new DateTime(2020, 04, 09)/*Thursday*/, OptionSymbol.GetLastDayOfTrading(weeklySymbol)); //this.last_trading_day = last_trading_day(this.expiry); this.last_trading_day = OptionSymbol.GetLastDayOfTrading(weeklySymbol); // get contracts with further expiry and sort them by strike var slice_T = (from i in chain where i.Expiry.Date == this.expiry select i).ToList(); var sorted_contracts = slice_T.OrderBy(x => x.Strike).ToList(); // self.Log("Expiry used: {} and shortest {}" .format(self.expiry, contracts_by_T[-1].Expiry.date()) ) // 2a. get the ATM closest CALL to short var calls = (from i in sorted_contracts where i.Right == OptionRight.Call && i.Strike >= spot_price select i).ToList(); //this.call = calls ? calls[0] : null; this.call = calls.Count > 0 ? calls.First() : null; // self.Log("delta call {}, self.call type {}" .format(self.call.Greeks.Delta, type(self.call))) // self.Log("implied vol {} " .format(self.call.ImpliedVolatility)) // 2b. get the ATM closest put to short var puts = (from i in sorted_contracts where i.Right == OptionRight.Put && i.Strike <= spot_price select i).ToList(); this.put = puts.Count > 0 ? puts.Last() : null; //if (put == null) this.Quit("put == null"); } }
public void RegisterOption(string fullForm, char?abbrForm, string description) { var symbol = new OptionSymbol(fullForm, abbrForm); if (Options.Any(e => e.SymbolMetadata.Equals(symbol))) { throw new ArgumentException("Duplicate option."); } Options.Add(new FlagOptionDefinition(symbol, description)); }
public void TestIfWeDetectCorrectlyWeekliesAndStandardOptionsAfterFeb2015() { var symbol = Symbol.CreateOption("SPY", Market.USA, OptionStyle.American, OptionRight.Call, 200, new DateTime(2016, 02, 19)); var weeklySymbol = Symbol.CreateOption("SPY", Market.USA, OptionStyle.American, OptionRight.Call, 200, new DateTime(2016, 02, 05)); Assert.True(OptionSymbol.IsStandardContract(symbol)); Assert.False(OptionSymbol.IsStandardContract(weeklySymbol)); Assert.AreEqual(new DateTime(2016, 02, 19) /*Friday*/, OptionSymbol.GetLastDayOfTrading(symbol)); Assert.AreEqual(new DateTime(2016, 02, 05) /*Friday*/, OptionSymbol.GetLastDayOfTrading(weeklySymbol)); }
public void TestIfWeDetectCorrectlyWeekliesAndStandardOptionsBeforeFeb2015() { var symbol = Symbol.CreateOption("SPY", Market.USA, OptionStyle.American, OptionRight.Call, 200, new DateTime(2012, 09, 22)); var weeklySymbol = Symbol.CreateOption("SPY", Market.USA, OptionStyle.American, OptionRight.Call, 200, new DateTime(2012, 09, 07)); Assert.True(OptionSymbol.IsStandard(symbol)); Assert.False(OptionSymbol.IsStandard(weeklySymbol)); Assert.AreEqual(new DateTime(2012, 09, 21) /*Friday*/, OptionSymbol.GetLastDayOfTrading(symbol)); Assert.AreEqual(new DateTime(2012, 09, 07) /*Friday*/, OptionSymbol.GetLastDayOfTrading(weeklySymbol)); }
static IOptionDefinition ResolveKeyValueOptionLabel( ICommandDefinition selectedCommand, string argument) { if (!OptionSymbol.CanBeFullForm(argument) && !OptionSymbol.CanBeAbbreviationSingleForm(argument)) { return(null); } return(selectedCommand.GetRegisteredOptions() .FirstOrDefault(o => o.Type == OptionType.KeyValue && o.IsMatch(argument))); }
public void IsOptionContractExpiredReturnsFalseIfActiveContract() { var symbol = Symbol.CreateOption( "BHP", Market.USA, OptionStyle.American, OptionRight.Call, 55m, new DateTime(2019, 9, 20)); Assert.IsFalse(OptionSymbol.IsOptionContractExpired(symbol, new DateTime(2019, 1, 1))); }
public void IsOptionContractExpiredReturnsFalseIfTimeOfDayDiffer() { var symbol = Symbol.CreateOption( "BHP", Market.USA, OptionStyle.American, OptionRight.Call, 55m, new DateTime(2022, 03, 11)); Assert.IsFalse(OptionSymbol.IsOptionContractExpired(symbol, new DateTime(2022, 03, 11))); }
public void TestIfWeDetectCorrectlyWeeklies() { var weeklySymbol = Symbol.CreateOption("SPY", Market.USA, OptionStyle.American, OptionRight.Call, 200, new DateTime(2020, 04, 10)); var monthlysymbol = Symbol.CreateOption("SPY", Market.USA, OptionStyle.American, OptionRight.Call, 200, new DateTime(2020, 04, 17)); Assert.True(OptionSymbol.IsWeekly(weeklySymbol)); Assert.False(OptionSymbol.IsWeekly(monthlysymbol)); Assert.AreEqual(new DateTime(2020, 04, 17) /*Friday*/, OptionSymbol.GetLastDayOfTrading(monthlysymbol)); //Good Friday on 10th so should be 9th Assert.AreEqual(new DateTime(2020, 04, 09) /*Thursday*/, OptionSymbol.GetLastDayOfTrading(weeklySymbol)); }
public void IsOptionContractExpiredReturnsTrueIfExpiredContract() { var symbol = Symbol.CreateOption( "BHP", Market.USA, OptionStyle.American, OptionRight.Call, 55m, new DateTime(2019, 9, 20)); Assert.IsTrue(OptionSymbol.IsOptionContractExpired(symbol, DateTime.UtcNow)); }
/// <summary> /// Determine if the given Option contract symbol is standard /// </summary> /// <returns>True if standard</returns> protected override bool IsStandard(Symbol symbol) { switch (symbol.SecurityType) { case SecurityType.FutureOption: return(FutureOptionSymbol.IsStandard(symbol)); case SecurityType.IndexOption: return(IndexOptionSymbol.IsStandard(symbol)); default: return(OptionSymbol.IsStandard(symbol)); } }
/// <summary> /// Returns universe, filtered by option type /// </summary> /// <returns></returns> internal OptionFilterUniverse ApplyOptionTypesFilter() { // memoization map for ApplyOptionTypesFilter() var memoizedMap = new Dictionary <DateTime, bool>(); Func <Symbol, bool> memoizedIsStandardType = symbol => { var dt = symbol.ID.Date; bool result; if (memoizedMap.TryGetValue(dt, out result)) { return(result); } var res = OptionSymbol.IsStandard(symbol); memoizedMap[dt] = res; return(res); }; _allSymbols = _allSymbols.Where(x => { switch (_type) { case Type.Weeklys: return(!memoizedIsStandardType(x)); case Type.Standard: return(memoizedIsStandardType(x)); case Type.Standard | Type.Weeklys: return(true); default: return(false); } }).ToList(); return(this); }
/// <summary> /// Returns universe, filtered by option type /// </summary> /// <returns></returns> internal OptionFilterUniverse ApplyOptionTypesFilter() { // memoization map for ApplyOptionTypesFilter() var memoizedMap = new Dictionary <DateTime, bool>(); Func <Symbol, bool> memoizedIsStandardType = symbol => { var dt = symbol.ID.Date; if (memoizedMap.ContainsKey(dt)) { return(memoizedMap[dt]); } var res = OptionSymbol.IsStandardContract(symbol); memoizedMap[dt] = res; return(res); }; var filtered = _allSymbols.Where(x => { switch (_type) { case Type.Weeklys: return(!memoizedIsStandardType(x)); case Type.Standard: return(memoizedIsStandardType(x)); case Type.Standard | Type.Weeklys: return(true); default: return(false); } }); _allSymbols = filtered.ToList(); return(this); }
/// <summary> /// Initializes this instance /// </summary> /// <param name="config">The <see cref="SubscriptionDataConfig"/></param> /// <param name="factorFile">The factor file to use</param> /// <param name="mapFile">The <see cref="MapFile"/> to use</param> public void Initialize( SubscriptionDataConfig config, FactorFile factorFile, MapFile mapFile) { _config = config; // Estimate delisting date. switch (config.Symbol.ID.SecurityType) { case SecurityType.Future: _delistingDate = config.Symbol.ID.Date; break; case SecurityType.Option: _delistingDate = OptionSymbol.GetLastDayOfTrading( config.Symbol); break; default: _delistingDate = mapFile.DelistingDate; break; } }
/// <summary> /// Get flag value. /// </summary> /// <param name="arg"> /// The full form or abbreviation form flag name. /// </param> /// <returns> /// If the flag is specified, return true, otherwise false. /// </returns> /// <exception cref="ArgumentNullException"> /// The flag argument is null. /// </exception> /// <exception cref="ArgumentException"> /// The flag argument is invalid or undefined. /// </exception> public bool GetFlagValue(string arg) { if (!IsSuccess) { throw new InvalidOperationException(); } try { var symbol = new OptionSymbol(arg); var option = definition.Flags.FirstOrDefault(c => c.Option.SymbolMetadata.Equals(symbol)); if (option == null) { throw new ParsingException(ArgsParsingErrorCode.FreeValueNotSupported, arg); } return(option.Value); } catch (ParsingException e) { throw new ArgumentException(e.Message); } }
public void IsOptionContractExpiredReturnsFalseForNonOptionSymbol() { Assert.IsFalse(OptionSymbol.IsOptionContractExpired(Symbols.SPY, DateTime.UtcNow)); }
/// <summary> /// Determine if the given Option contract symbol is standard /// </summary> /// <returns>True if standard</returns> protected override bool IsStandard(Symbol symbol) { return(symbol.SecurityType == SecurityType.FutureOption ? FutureOptionSymbol.IsStandard(symbol) : OptionSymbol.IsStandard(symbol)); }
/// <summary> /// Initializes the <see cref="SubscriptionDataReader"/> instance /// </summary> /// <remarks>Should be called after all consumers of <see cref="NewTradableDate"/> event are set, /// since it will produce events.</remarks> public void Initialize() { if (_initialized) { return; } //Save the type of data we'll be getting from the source. try { _dataFactory = _config.Type.GetBaseDataInstance(); } catch (ArgumentException exception) { OnInvalidConfigurationDetected(new InvalidConfigurationDetectedEventArgs(exception.Message)); _endOfStream = true; return; } //If its quandl set the access token in data factory: var quandl = _dataFactory as Quandl; if (quandl != null) { if (!Quandl.IsAuthCodeSet) { Quandl.SetAuthCode(Config.Get("quandl-auth-token")); } } // If Tiingo data, set the access token in data factory var tiingo = _dataFactory as TiingoDailyData; if (tiingo != null) { if (!Tiingo.IsAuthCodeSet) { Tiingo.SetAuthCode(Config.Get("tiingo-auth-token")); } } // If USEnergyInformation data, set the access token in data factory var energyInformation = _dataFactory as USEnergyInformation; if (energyInformation != null) { if (!USEnergyInformation.IsAuthCodeSet) { USEnergyInformation.SetAuthCode(Config.Get("us-energy-information-auth-token")); } } _factorFile = new FactorFile(_config.Symbol.Value, new List <FactorFileRow>()); _mapFile = new MapFile(_config.Symbol.Value, new List <MapFileRow>()); // load up the map files for equities, options, and custom data if it supports it. // Only load up factor files for equities if (_config.TickerShouldBeMapped()) { try { var mapFile = _mapFileResolver.ResolveMapFile(_config.Symbol, _config.Type); // only take the resolved map file if it has data, otherwise we'll use the empty one we defined above if (mapFile.Any()) { _mapFile = mapFile; } if (!_config.IsCustomData && _config.SecurityType != SecurityType.Option) { var factorFile = _factorFileProvider.Get(_config.Symbol); _hasScaleFactors = factorFile != null; if (_hasScaleFactors) { _factorFile = factorFile; // if factor file has minimum date, update start period if before minimum date if (!_isLiveMode && _factorFile != null && _factorFile.FactorFileMinimumDate.HasValue) { if (_periodStart < _factorFile.FactorFileMinimumDate.Value) { _periodStart = _factorFile.FactorFileMinimumDate.Value; OnNumericalPrecisionLimited( new NumericalPrecisionLimitedEventArgs( $"Data for symbol {_config.Symbol.Value} has been limited due to numerical precision issues in the factor file. " + $"The starting date has been set to {_factorFile.FactorFileMinimumDate.Value.ToShortDateString()}.")); } } } } } catch (Exception err) { Log.Error(err, "Fetching Price/Map Factors: " + _config.Symbol.ID + ": "); } } // Estimate delisting date. switch (_config.Symbol.ID.SecurityType) { case SecurityType.Future: _delistingDate = _config.Symbol.ID.Date; break; case SecurityType.Option: _delistingDate = OptionSymbol.GetLastDayOfTrading(_config.Symbol); break; default: _delistingDate = _mapFile.DelistingDate; break; } // adding a day so we stop at EOD _delistingDate = _delistingDate.AddDays(1); _subscriptionFactoryEnumerator = ResolveDataEnumerator(true); _initialized = true; }
/// <summary> /// Determine if the given Option contract symbol is standard /// </summary> /// <returns>True if standard</returns> protected override bool IsStandard(Symbol symbol) { return(OptionSymbol.IsStandard(symbol)); }
/// <summary> /// Subscription data reader takes a subscription request, loads the type, accepts the data source and enumerate on the results. /// </summary> /// <param name="config">Subscription configuration object</param> /// <param name="periodStart">Start date for the data request/backtest</param> /// <param name="periodFinish">Finish date for the data request/backtest</param> /// <param name="resultHandler">Result handler used to push error messages and perform sampling on skipped days</param> /// <param name="mapFileResolver">Used for resolving the correct map files</param> /// <param name="factorFileProvider">Used for getting factor files</param> /// <param name="dataProvider">Used for getting files not present on disk</param> /// <param name="dataCacheProvider">Used for caching files</param> /// <param name="tradeableDates">Defines the dates for which we'll request data, in order, in the security's exchange time zone</param> /// <param name="isLiveMode">True if we're in live mode, false otherwise</param> /// <param name="includeAuxilliaryData">True if we want to emit aux data, false to only emit price data</param> public SubscriptionDataReader(SubscriptionDataConfig config, DateTime periodStart, DateTime periodFinish, IResultHandler resultHandler, MapFileResolver mapFileResolver, IFactorFileProvider factorFileProvider, IDataProvider dataProvider, IEnumerable <DateTime> tradeableDates, bool isLiveMode, IDataCacheProvider dataCacheProvider, bool includeAuxilliaryData = true) { //Save configuration of data-subscription: _config = config; _auxiliaryData = new Queue <BaseData>(); //Save Start and End Dates: _periodStart = periodStart; _periodFinish = periodFinish; _dataProvider = dataProvider; _dataCacheProvider = dataCacheProvider; //Save access to securities _isLiveMode = isLiveMode; _includeAuxilliaryData = includeAuxilliaryData; //Save the type of data we'll be getting from the source. //Create the dynamic type-activators: var objectActivator = ObjectActivator.GetActivator(config.Type); _resultHandler = resultHandler; _tradeableDates = tradeableDates.GetEnumerator(); if (objectActivator == null) { _resultHandler.ErrorMessage("Custom data type '" + config.Type.Name + "' missing parameterless constructor E.g. public " + config.Type.Name + "() { }"); _endOfStream = true; return; } //Create an instance of the "Type": var userObj = objectActivator.Invoke(new object[] { config.Type }); _dataFactory = userObj as BaseData; //If its quandl set the access token in data factory: var quandl = _dataFactory as Quandl; if (quandl != null) { if (!Quandl.IsAuthCodeSet) { Quandl.SetAuthCode(Config.Get("quandl-auth-token")); } } // If Tiingo data, set the access token in data factory var tiingo = _dataFactory as TiingoDailyData; if (tiingo != null) { if (!Tiingo.IsAuthCodeSet) { Tiingo.SetAuthCode(Config.Get("tiingo-auth-token")); } } _factorFile = new FactorFile(config.Symbol.Value, new List <FactorFileRow>()); _mapFile = new MapFile(config.Symbol.Value, new List <MapFileRow>()); // load up the map and factor files for equities if (!config.IsCustomData && config.SecurityType == SecurityType.Equity) { try { var mapFile = mapFileResolver.ResolveMapFile(config.Symbol.ID.Symbol, config.Symbol.ID.Date); // only take the resolved map file if it has data, otherwise we'll use the empty one we defined above if (mapFile.Any()) { _mapFile = mapFile; } var factorFile = factorFileProvider.Get(_config.Symbol); _hasScaleFactors = factorFile != null; if (_hasScaleFactors) { _factorFile = factorFile; // if factor file has minimum date, update start period if before minimum date if (!_isLiveMode && _factorFile != null && _factorFile.FactorFileMinimumDate.HasValue) { if (_periodStart < _factorFile.FactorFileMinimumDate.Value) { _periodStart = _factorFile.FactorFileMinimumDate.Value; _resultHandler.DebugMessage( string.Format("Data for symbol {0} has been limited due to numerical precision issues in the factor file. The starting date has been set to {1}.", config.Symbol.Value, _factorFile.FactorFileMinimumDate.Value.ToShortDateString())); } } } } catch (Exception err) { Log.Error(err, "Fetching Price/Map Factors: " + config.Symbol.ID + ": "); } } // load up the map and factor files for underlying of equity option if (!config.IsCustomData && config.SecurityType == SecurityType.Option) { try { var mapFile = mapFileResolver.ResolveMapFile(config.Symbol.Underlying.ID.Symbol, config.Symbol.Underlying.ID.Date); // only take the resolved map file if it has data, otherwise we'll use the empty one we defined above if (mapFile.Any()) { _mapFile = mapFile; } } catch (Exception err) { Log.Error(err, "Map Factors: " + config.Symbol.ID + ": "); } } // Estimate delisting date. switch (_config.Symbol.ID.SecurityType) { case SecurityType.Future: _delistingDate = _config.Symbol.ID.Date; break; case SecurityType.Option: _delistingDate = OptionSymbol.GetLastDayOfTrading(_config.Symbol); break; default: _delistingDate = _mapFile.DelistingDate; break; } _subscriptionFactoryEnumerator = ResolveDataEnumerator(true); }
/// <summary> /// Initializes the <see cref="SubscriptionDataReader"/> instance /// </summary> public void Initialize() { if (_initialized) { return; } //Save the type of data we'll be getting from the source. //Create the dynamic type-activators: var objectActivator = ObjectActivator.GetActivator(_config.Type); if (objectActivator == null) { OnInvalidConfigurationDetected( new InvalidConfigurationDetectedEventArgs( $"Custom data type \'{_config.Type.Name}\' missing parameterless constructor " + $"E.g. public {_config.Type.Name}() {{ }}")); _endOfStream = true; return; } //Create an instance of the "Type": var userObj = objectActivator.Invoke(new object[] { _config.Type }); _dataFactory = userObj as BaseData; //If its quandl set the access token in data factory: var quandl = _dataFactory as Quandl; if (quandl != null) { if (!Quandl.IsAuthCodeSet) { Quandl.SetAuthCode(Config.Get("quandl-auth-token")); } } // If Tiingo data, set the access token in data factory var tiingo = _dataFactory as TiingoDailyData; if (tiingo != null) { if (!Tiingo.IsAuthCodeSet) { Tiingo.SetAuthCode(Config.Get("tiingo-auth-token")); } } _factorFile = new FactorFile(_config.Symbol.Value, new List <FactorFileRow>()); _mapFile = new MapFile(_config.Symbol.Value, new List <MapFileRow>()); // load up the map and factor files for equities if (!_config.IsCustomData && _config.SecurityType == SecurityType.Equity) { try { var mapFile = _mapFileResolver.ResolveMapFile(_config.Symbol.ID.Symbol, _config.Symbol.ID.Date); // only take the resolved map file if it has data, otherwise we'll use the empty one we defined above if (mapFile.Any()) { _mapFile = mapFile; } var factorFile = _factorFileProvider.Get(_config.Symbol); _hasScaleFactors = factorFile != null; if (_hasScaleFactors) { _factorFile = factorFile; // if factor file has minimum date, update start period if before minimum date if (!_isLiveMode && _factorFile != null && _factorFile.FactorFileMinimumDate.HasValue) { if (_periodStart < _factorFile.FactorFileMinimumDate.Value) { _periodStart = _factorFile.FactorFileMinimumDate.Value; OnNumericalPrecisionLimited( new NumericalPrecisionLimitedEventArgs( $"Data for symbol {_config.Symbol.Value} has been limited due to numerical precision issues in the factor file. " + $"The starting date has been set to {_factorFile.FactorFileMinimumDate.Value.ToShortDateString()}.")); } } } } catch (Exception err) { Log.Error(err, "Fetching Price/Map Factors: " + _config.Symbol.ID + ": "); } } // load up the map and factor files for underlying of equity option if (!_config.IsCustomData && _config.SecurityType == SecurityType.Option) { try { var mapFile = _mapFileResolver.ResolveMapFile(_config.Symbol.Underlying.ID.Symbol, _config.Symbol.Underlying.ID.Date); // only take the resolved map file if it has data, otherwise we'll use the empty one we defined above if (mapFile.Any()) { _mapFile = mapFile; } } catch (Exception err) { Log.Error(err, "Map Factors: " + _config.Symbol.ID + ": "); } } // Estimate delisting date. switch (_config.Symbol.ID.SecurityType) { case SecurityType.Future: _delistingDate = _config.Symbol.ID.Date; break; case SecurityType.Option: _delistingDate = OptionSymbol.GetLastDayOfTrading(_config.Symbol); break; default: _delistingDate = _mapFile.DelistingDate; break; } _subscriptionFactoryEnumerator = ResolveDataEnumerator(true); _initialized = true; }