public void DoesNotLoopEndlesslyIfGetCashBalanceAlwaysThrows() { var ib = _interactiveBrokersBrokerage; Assert.IsTrue(ib.IsConnected); ib.Disconnect(); Assert.IsFalse(ib.IsConnected); var algorithm = new QCAlgorithm(); var marketHoursDatabase = MarketHoursDatabase.FromDataFolder(); var symbolPropertiesDataBase = SymbolPropertiesDatabase.FromDataFolder(); var securityService = new SecurityService(algorithm.Portfolio.CashBook, marketHoursDatabase, symbolPropertiesDataBase, algorithm, RegisteredSecurityDataTypesProvider.Null, new SecurityCacheProvider(algorithm.Portfolio)); algorithm.Securities.SetSecurityService(securityService); algorithm.SetLiveMode(true); var transactionHandler = new BrokerageTransactionHandlerTests.TestBrokerageTransactionHandler(); var testResultHandler = new TestResultHandler(); transactionHandler.Initialize(algorithm, ib, testResultHandler); // Advance current time UTC so cash sync is performed transactionHandler.TestCurrentTimeUtc = transactionHandler.TestCurrentTimeUtc.AddDays(2); // simulate connect always failing EventHandler handler = (s, e) => ib.Client.ClientSocket.Close(); ib.Client.ConnectAck += handler; try { while (true) { transactionHandler.ProcessSynchronousEvents(); Assert.IsFalse(ib.IsConnected); Thread.Sleep(1000); } } catch (Exception exception) { // expect exception from ProcessSynchronousEvents when max attempts reached Assert.That(exception.Message.Contains("maximum number of attempts")); } // perform clean connect so the test can complete Teardown without exceptions ib.Client.ConnectAck -= handler; ib.Connect(); testResultHandler.Exit(); Assert.IsTrue(ib.IsConnected); }
/// <summary> /// Constructor for brokerage /// </summary> /// <param name="wssUrl">websockets url</param> /// <param name="websocket">instance of websockets client</param> /// <param name="restClient">instance of rest client</param> /// <param name="apiKey">api key</param> /// <param name="apiSecret">api secret</param> /// <param name="algorithm">the algorithm instance is required to retrieve account type</param> /// <param name="priceProvider">The price provider for missing FX conversion rates</param> public BitfinexBrokerage(string wssUrl, IWebSocket websocket, IRestClient restClient, string apiKey, string apiSecret, IAlgorithm algorithm, IPriceProvider priceProvider) : base(wssUrl, websocket, restClient, apiKey, apiSecret, Market.Bitfinex, "Bitfinex") { _subscriptionManager = new BitfinexSubscriptionManager(this, wssUrl, _symbolMapper); _symbolPropertiesDatabase = SymbolPropertiesDatabase.FromDataFolder(); _algorithm = algorithm; WebSocket.Open += (sender, args) => { SubscribeAuth(); }; }
public void TestsFileSystemDataFeedSpeed() { var job = new BacktestNodePacket(); var resultHandler = new BacktestingResultHandler(); var mapFileProvider = new LocalDiskMapFileProvider(); var factorFileProvider = new LocalDiskFactorFileProvider(mapFileProvider); var dataProvider = new DefaultDataProvider(); var algorithm = PerformanceBenchmarkAlgorithms.SingleSecurity_Second; var feed = new FileSystemDataFeed(); var marketHoursDatabase = MarketHoursDatabase.FromDataFolder(); var symbolPropertiesDataBase = SymbolPropertiesDatabase.FromDataFolder(); var dataManager = new DataManager(feed, new UniverseSelection( algorithm, new SecurityService(algorithm.Portfolio.CashBook, marketHoursDatabase, symbolPropertiesDataBase, algorithm, RegisteredSecurityDataTypesProvider.Null)), algorithm, algorithm.TimeKeeper, marketHoursDatabase, false, RegisteredSecurityDataTypesProvider.Null); algorithm.SubscriptionManager.SetDataManager(dataManager); var synchronizer = new Synchronizer(); synchronizer.Initialize(algorithm, dataManager); feed.Initialize(algorithm, job, resultHandler, mapFileProvider, factorFileProvider, dataProvider, dataManager, synchronizer); algorithm.Initialize(); algorithm.PostInitialize(); var cancellationTokenSource = new CancellationTokenSource(); var count = 0; var stopwatch = Stopwatch.StartNew(); var lastMonth = algorithm.StartDate.Month; foreach (var timeSlice in synchronizer.StreamData(cancellationTokenSource.Token)) { if (timeSlice.Time.Month != lastMonth) { var elapsed = stopwatch.Elapsed.TotalSeconds; var thousands = count / 1000d; Console.WriteLine($"{DateTime.Now} - Time: {timeSlice.Time}: KPS: {thousands/elapsed}"); lastMonth = timeSlice.Time.Month; } count++; } Console.WriteLine("Count: " + count); stopwatch.Stop(); feed.Exit(); dataManager.RemoveAllSubscriptions(); Console.WriteLine($"Elapsed time: {stopwatch.Elapsed} KPS: {count/1000d/stopwatch.Elapsed.TotalSeconds}"); }
private Security GetSecurity(Symbol symbol, DataNormalizationMode mode) { var symbolProperties = SymbolPropertiesDatabase.FromDataFolder() .GetSymbolProperties(symbol.ID.Market, symbol.Value, symbol.ID.SecurityType, Currencies.USD); Security security; if (symbol.ID.SecurityType == SecurityType.Equity) { security = new QuantConnect.Securities.Equity.Equity( SecurityExchangeHours.AlwaysOpen(TimeZones.NewYork), new SubscriptionDataConfig( typeof(TradeBar), symbol, Resolution.Minute, TimeZones.NewYork, TimeZones.NewYork, true, true, false ), new Cash(Currencies.USD, 0, 1m), symbolProperties, ErrorCurrencyConverter.Instance ); } else { security = new QuantConnect.Securities.Forex.Forex( SecurityExchangeHours.AlwaysOpen(TimeZones.NewYork), new Cash(Currencies.USD, 0, 1m), new SubscriptionDataConfig( typeof(TradeBar), symbol, Resolution.Minute, TimeZones.NewYork, TimeZones.NewYork, true, true, false ), symbolProperties, ErrorCurrencyConverter.Instance ); } var TimeKeeper = new TimeKeeper(DateTime.Now.ConvertToUtc(TimeZones.NewYork), new[] { TimeZones.NewYork }); security.SetLocalTimeKeeper(TimeKeeper.GetLocalTimeKeeper(TimeZones.NewYork)); security.SetDataNormalizationMode(mode); return(security); }
public void FastExitsDoNotThrowUnhandledExceptions() { var algorithm = new AlgorithmStub(); // job is used to send into DataQueueHandler var job = new LiveNodePacket(); // result handler is used due to dependency in SubscriptionDataReader var resultHandler = new BacktestingResultHandler(); var feed = new TestableLiveTradingDataFeed(); var marketHoursDatabase = MarketHoursDatabase.FromDataFolder(); var symbolPropertiesDataBase = SymbolPropertiesDatabase.FromDataFolder(); var securityService = new SecurityService( algorithm.Portfolio.CashBook, marketHoursDatabase, symbolPropertiesDataBase, algorithm); algorithm.Securities.SetSecurityService(securityService); var dataManager = new DataManager(feed, new UniverseSelection(feed, algorithm, securityService), algorithm.Settings, algorithm.TimeKeeper, marketHoursDatabase); algorithm.SubscriptionManager.SetDataManager(dataManager); algorithm.AddSecurities(Resolution.Tick, Enumerable.Range(0, 20).Select(x => x.ToString()).ToList()); var getNextTicksFunction = Enumerable.Range(0, 20).Select(x => new Tick { Symbol = SymbolCache.GetSymbol(x.ToString()) }).ToList(); feed.DataQueueHandler = new FuncDataQueueHandler(handler => getNextTicksFunction); var mapFileProvider = new LocalDiskMapFileProvider(); var fileProvider = new DefaultDataProvider(); feed.Initialize(algorithm, job, resultHandler, mapFileProvider, new LocalDiskFactorFileProvider(mapFileProvider), fileProvider, dataManager); var unhandledExceptionWasThrown = false; try { feed.Exit(); } catch (Exception ex) { QuantConnect.Logging.Log.Error(ex.ToString()); unhandledExceptionWasThrown = true; } Thread.Sleep(500); Assert.IsFalse(unhandledExceptionWasThrown); }
public void Setup() { var timeKeeper = new TimeKeeper(new DateTime(2015, 12, 07)); _securityManager = new SecurityManager(timeKeeper); _securityTransactionManager = new SecurityTransactionManager(_securityManager); _securityPortfolioManager = new SecurityPortfolioManager(_securityManager, _securityTransactionManager); _subscriptionManager = new SubscriptionManager(new AlgorithmSettings(), timeKeeper); _marketHoursDatabase = MarketHoursDatabase.FromDataFolder(); _symbolPropertiesDatabase = SymbolPropertiesDatabase.FromDataFolder(); _securityInitializer = SecurityInitializer.Null; }
/// <summary> /// <see cref = "QuantBook" /> constructor. /// Provides access to data for quantitative analysis /// </summary> public QuantBook() : base() { try { using (Py.GIL()) { _pandas = Py.Import("pandas"); } // By default, set start date to end data which is yesterday SetStartDate(EndDate); // Sets PandasConverter SetPandasConverter(); // Initialize History Provider var composer = new Composer(); var algorithmHandlers = LeanEngineAlgorithmHandlers.FromConfiguration(composer); _dataCacheProvider = new ZipDataCacheProvider(algorithmHandlers.DataProvider); var symbolPropertiesDataBase = SymbolPropertiesDatabase.FromDataFolder(); var securityService = new SecurityService(Portfolio.CashBook, MarketHoursDatabase, symbolPropertiesDataBase, this); Securities.SetSecurityService(securityService); SubscriptionManager.SetDataManager( new DataManager(new NullDataFeed(), new UniverseSelection(this, securityService), this, TimeKeeper, MarketHoursDatabase, false)); var mapFileProvider = algorithmHandlers.MapFileProvider; HistoryProvider = composer.GetExportedValueByTypeName <IHistoryProvider>(Config.Get("history-provider", "SubscriptionDataReaderHistoryProvider")); HistoryProvider.Initialize( new HistoryProviderInitializeParameters( null, null, algorithmHandlers.DataProvider, _dataCacheProvider, mapFileProvider, algorithmHandlers.FactorFileProvider, null ) ); SetOptionChainProvider(new CachingOptionChainProvider(new BacktestingOptionChainProvider())); SetFutureChainProvider(new CachingFutureChainProvider(new BacktestingFutureChainProvider())); } catch (Exception exception) { throw new Exception("QuantBook.Main(): " + exception); } }
public static Security GetSecurity(decimal price = 1m, SecurityType securityType = SecurityType.Crypto, Resolution resolution = Resolution.Minute, string symbol = "BTCUSD", string market = Market.GDAX, string quoteCurrency = "USD") { return(new Security( SecurityExchangeHours.AlwaysOpen(TimeZones.Utc), CreateConfig(symbol, market, securityType, resolution), new Cash(quoteCurrency, 1000, price), SymbolPropertiesDatabase.FromDataFolder().GetSymbolProperties(market, symbol, SecurityType.Crypto, quoteCurrency), ErrorCurrencyConverter.Instance, RegisteredSecurityDataTypesProvider.Null, new SecurityCache() )); }
public void TestAlgorithmManagerSpeed() { var algorithmManager = new AlgorithmManager(false); var algorithm = PerformanceBenchmarkAlgorithms.SingleSecurity_Second; var job = new BacktestNodePacket(1, 2, "3", null, 9m, $"{nameof(AlgorithmManagerTests)}.{nameof(TestAlgorithmManagerSpeed)}"); var feed = new MockDataFeed(); var marketHoursDatabase = MarketHoursDatabase.FromDataFolder(); var symbolPropertiesDataBase = SymbolPropertiesDatabase.FromDataFolder(); var dataManager = new DataManager(feed, new UniverseSelection( algorithm, new SecurityService(algorithm.Portfolio.CashBook, marketHoursDatabase, symbolPropertiesDataBase, algorithm, RegisteredSecurityDataTypesProvider.Null, new SecurityCacheProvider(algorithm.Portfolio))), algorithm, algorithm.TimeKeeper, marketHoursDatabase, false, RegisteredSecurityDataTypesProvider.Null); algorithm.SubscriptionManager.SetDataManager(dataManager); var transactions = new BacktestingTransactionHandler(); var results = new BacktestingResultHandler(); var realtime = new BacktestingRealTimeHandler(); var leanManager = new NullLeanManager(); var alphas = new NullAlphaHandler(); var token = new CancellationToken(); var nullSynchronizer = new NullSynchronizer(algorithm); algorithm.Initialize(); algorithm.PostInitialize(); results.Initialize(job, new QuantConnect.Messaging.Messaging(), new Api.Api(), transactions); results.SetAlgorithm(algorithm, algorithm.Portfolio.TotalPortfolioValue); transactions.Initialize(algorithm, new BacktestingBrokerage(algorithm), results); feed.Initialize(algorithm, job, results, null, null, null, dataManager, null); Log.Trace("Starting algorithm manager loop to process " + nullSynchronizer.Count + " time slices"); var sw = Stopwatch.StartNew(); algorithmManager.Run(job, algorithm, nullSynchronizer, transactions, results, realtime, leanManager, alphas, token); sw.Stop(); realtime.Exit(); results.Exit(); var thousands = nullSynchronizer.Count / 1000d; var seconds = sw.Elapsed.TotalSeconds; Log.Trace("COUNT: " + nullSynchronizer.Count + " KPS: " + thousands / seconds); }
public void Setup() { var sunday = new LocalMarketHours(DayOfWeek.Sunday, new TimeSpan(17, 0, 0), TimeSpan.FromTicks(Time.OneDay.Ticks - 1)); var monday = LocalMarketHours.OpenAllDay(DayOfWeek.Monday); var tuesday = LocalMarketHours.OpenAllDay(DayOfWeek.Tuesday); var wednesday = LocalMarketHours.OpenAllDay(DayOfWeek.Wednesday); var thursday = LocalMarketHours.OpenAllDay(DayOfWeek.Thursday); var friday = new LocalMarketHours(DayOfWeek.Friday, TimeSpan.Zero, new TimeSpan(17, 0, 0)); var earlyCloses = new Dictionary <DateTime, TimeSpan>(); var lateOpens = new Dictionary <DateTime, TimeSpan>(); _exchangeHours = new SecurityExchangeHours(TimeZones.NewYork, USHoliday.Dates.Select(x => x.Date), new[] { sunday, monday, tuesday, wednesday, thursday, friday }.ToDictionary(x => x.DayOfWeek), earlyCloses, lateOpens); _liveTradingDataFeed = new TestableLiveTradingDataFeed(); var jobPacket = new LiveNodePacket() { DeployId = "", Brokerage = BrokerageName.OandaBrokerage.ToString(), DataQueueHandler = "LiveDataQueue" }; var algo = new TestAlgorithm(); var marketHoursDatabase = MarketHoursDatabase.FromDataFolder(); var symbolPropertiesDataBase = SymbolPropertiesDatabase.FromDataFolder(); var dataPermissionManager = new DataPermissionManager(); var dataProvider = new DefaultDataProvider(); var dataManager = new DataManager(_liveTradingDataFeed, new UniverseSelection( algo, new SecurityService(algo.Portfolio.CashBook, marketHoursDatabase, symbolPropertiesDataBase, algo, RegisteredSecurityDataTypesProvider.Null, new SecurityCacheProvider(algo.Portfolio)), dataPermissionManager, dataProvider), algo, algo.TimeKeeper, marketHoursDatabase, true, RegisteredSecurityDataTypesProvider.Null, dataPermissionManager); algo.SubscriptionManager.SetDataManager(dataManager); _liveSynchronizer = new LiveSynchronizer(); _liveSynchronizer.Initialize(algo, dataManager); _liveTradingDataFeed.Initialize(algo, jobPacket, new LiveTradingResultHandler(), new LocalDiskMapFileProvider(), null, dataProvider, dataManager, _liveSynchronizer, new DataChannelProvider()); algo.Initialize(); _config = SecurityTests.CreateTradeBarConfig(); }
/// <summary> /// Constructor for brokerage /// </summary> /// <param name="websocket">instance of websockets client</param> /// <param name="restClient">instance of rest client</param> /// <param name="apiKey">api key</param> /// <param name="apiSecret">api secret</param> /// <param name="algorithm">the algorithm instance is required to retrieve account type</param> /// <param name="priceProvider">The price provider for missing FX conversion rates</param> /// <param name="aggregator">consolidate ticks</param> public BitfinexBrokerage(IWebSocket websocket, IRestClient restClient, string apiKey, string apiSecret, IAlgorithm algorithm, IPriceProvider priceProvider, IDataAggregator aggregator) : base(WebSocketUrl, websocket, restClient, apiKey, apiSecret, TimeSpan.FromMinutes(1), "Bitfinex") { SubscriptionManager = new BitfinexSubscriptionManager(this, WebSocketUrl, _symbolMapper); _symbolPropertiesDatabase = SymbolPropertiesDatabase.FromDataFolder(); _algorithm = algorithm; _aggregator = aggregator; WebSocket.Open += (sender, args) => { SubscribeAuth(); }; }
public void Setup() { SymbolCache.Clear(); var timeKeeper = new TimeKeeper(new DateTime(2015, 12, 07)); _securityManager = new SecurityManager(timeKeeper); _securityTransactionManager = new SecurityTransactionManager(null, _securityManager); _securityPortfolioManager = new SecurityPortfolioManager(_securityManager, _securityTransactionManager); _subscriptionManager = new SubscriptionManager(timeKeeper, new DataManagerStub()); _marketHoursDatabase = MarketHoursDatabase.FromDataFolder(); _symbolPropertiesDatabase = SymbolPropertiesDatabase.FromDataFolder(); _securityInitializer = SecurityInitializer.Null; }
public void NextSymbol_ThrowsNoTickersAvailableException_WhenAllSymbolsGenerated(SecurityType securityType, string market) { var db = SymbolPropertiesDatabase.FromDataFolder(); var symbolCount = db.GetSymbolPropertiesList(market, securityType).Count(); for (var i = 0; i < symbolCount; i++) { randomValueGenerator.NextSymbol(securityType, market); } Assert.Throws <NoTickersAvailableException>(() => randomValueGenerator.NextSymbol(securityType, market) ); }
public void CustomEntriesStoredAndFetched() { var database = SymbolPropertiesDatabase.FromDataFolder(); var ticker = "BTC"; var properties = SymbolProperties.GetDefault("USD"); // Set the entry Assert.IsTrue(database.SetEntry(Market.USA, ticker, SecurityType.Base, properties)); // Fetch the entry to ensure we can access it with the ticker var fetchedProperties = database.GetSymbolProperties(Market.USA, ticker, SecurityType.Base, "USD"); Assert.AreSame(properties, fetchedProperties); }
/// <summary> /// Creates the canonical <see cref="Future"/> chain security for a given symbol /// </summary> /// <param name="algorithm">The algorithm instance to create universes for</param> /// <param name="symbol">Symbol of the future</param> /// <param name="settings">Universe settings define attributes of created subscriptions, such as their resolution and the minimum time in universe before they can be removed</param> /// <param name="initializer">Performs extra initialization (such as setting models) after we create a new security object</param> /// <returns><see cref="Future"/> for the given symbol</returns> protected virtual Future CreateFutureChainSecurity(QCAlgorithmFramework algorithm, Symbol symbol, UniverseSettings settings, ISecurityInitializer initializer) { var market = symbol.ID.Market; var marketHoursEntry = MarketHoursDatabase.FromDataFolder() .GetEntry(market, symbol, SecurityType.Future); var symbolProperties = SymbolPropertiesDatabase.FromDataFolder() .GetSymbolProperties(market, symbol, SecurityType.Future, CashBook.AccountCurrency); return((Future)SecurityManager.CreateSecurity(typeof(ZipEntryName), algorithm.Portfolio, algorithm.SubscriptionManager, marketHoursEntry.ExchangeHours, marketHoursEntry.DataTimeZone, symbolProperties, initializer, symbol, settings.Resolution, settings.FillForward, settings.Leverage, settings.ExtendedMarketHours, false, false, algorithm.LiveMode, false, false)); }
/// <summary> /// Creates Lean Symbol /// </summary> /// <param name="ticker"></param> /// <returns></returns> internal Symbol GetSymbol(string ticker) { if (_symbolMapper.IsKnownBrokerageSymbol(ticker)) { return(_symbolMapper.GetLeanSymbol(ticker, SecurityType.Crypto, Market.Bitfinex)); } else if (SymbolPropertiesDatabase.FromDataFolder().ContainsKey(Market.Bitfinex, ticker, SecurityType.Crypto)) { return(Symbol.Create(ticker, SecurityType.Crypto, Market.Bitfinex)); } else { throw new Exception($"Unknown ticker symbol: {ticker}"); } }
public void LoadsPriceMagnifier(string ticker, string market, int expectedPriceMagnifier) { var db = SymbolPropertiesDatabase.FromDataFolder(); var symbol = Symbol.Create(ticker, SecurityType.Future, market); var symbolProperties = db.GetSymbolProperties(symbol.ID.Market, symbol, symbol.SecurityType, "USD"); Assert.AreEqual(expectedPriceMagnifier, symbolProperties.PriceMagnifier); var futureOption = Symbol.CreateOption(symbol, symbol.ID.Market, OptionStyle.American, OptionRight.Call, 1, new DateTime(2021, 10, 14)); var symbolPropertiesFop = db.GetSymbolProperties(futureOption.ID.Market, futureOption, futureOption.SecurityType, "USD"); Assert.AreEqual(expectedPriceMagnifier, symbolPropertiesFop.PriceMagnifier); }
public void BaseCurrencyIsNotEqualToQuoteCurrency(string market, SecurityType securityType) { var db = SymbolPropertiesDatabase.FromDataFolder(); var spList = db.GetSymbolPropertiesList(market, securityType).ToList(); Assert.IsNotEmpty(spList); foreach (var kvp in spList) { var quoteCurrency = kvp.Value.QuoteCurrency; var baseCurrency = kvp.Key.Symbol.Substring(0, kvp.Key.Symbol.Length - quoteCurrency.Length); Assert.AreNotEqual(baseCurrency, quoteCurrency); } }
public void HasCurrencySymbolForEachForexPair(SecurityType securityType, string market) { var symbols = SymbolPropertiesDatabase .FromDataFolder() .GetSymbolPropertiesList(market, securityType) .Select(x => x.Key.Symbol); foreach (var symbol in symbols) { string baseCurrency, quoteCurrency; Forex.DecomposeCurrencyPair(symbol, out baseCurrency, out quoteCurrency); Assert.IsTrue(!string.IsNullOrWhiteSpace(Currencies.GetCurrencySymbol(baseCurrency)), "Missing currency symbol for: " + baseCurrency); Assert.IsTrue(!string.IsNullOrWhiteSpace(Currencies.GetCurrencySymbol(quoteCurrency)), "Missing currency symbol for: " + quoteCurrency); } }
public void ReadsFuturesOptionsEntries(string ticker, string market, int expectedMultiplier, double expectedMinimumPriceFluctuation) { var future = Symbol.CreateFuture(ticker, market, SecurityIdentifier.DefaultDate); var option = Symbol.CreateOption( future, market, default(OptionStyle), default(OptionRight), default(decimal), SecurityIdentifier.DefaultDate); var db = SymbolPropertiesDatabase.FromDataFolder(); var results = db.GetSymbolProperties(market, option, SecurityType.FutureOption, "USD"); Assert.AreEqual((decimal)expectedMultiplier, results.ContractMultiplier); Assert.AreEqual((decimal)expectedMinimumPriceFluctuation, results.MinimumPriceVariation); }
public void NextSymbol_CreatesSymbol_WithEntryInSymbolPropertiesDatabase(SecurityType securityType, string market) { var symbol = randomValueGenerator.NextSymbol(securityType, market); var db = SymbolPropertiesDatabase.FromDataFolder(); if (db.ContainsKey(market, SecurityDatabaseKey.Wildcard, securityType)) { // there is a wildcard entry, so no need to check whether there is a specific entry for the symbol Assert.Pass(); } else { // there is no wildcard entry, so there should be a specific entry for the symbol instead Assert.IsTrue(db.ContainsKey(market, symbol, securityType)); } }
private void SetupImpl(IDataQueueHandler dataQueueHandler, Synchronizer synchronizer, IDataAggregator dataAggregator) { _dataFeed = new TestableLiveTradingDataFeed(dataQueueHandler ?? new FakeDataQueue(dataAggregator ?? new AggregationManager())); _algorithm = new AlgorithmStub(createDataManager: false); _synchronizer = synchronizer ?? new LiveSynchronizer(); var registeredTypesProvider = new RegisteredSecurityDataTypesProvider(); var securityService = new SecurityService(_algorithm.Portfolio.CashBook, MarketHoursDatabase.FromDataFolder(), SymbolPropertiesDatabase.FromDataFolder(), _algorithm, registeredTypesProvider, new SecurityCacheProvider(_algorithm.Portfolio)); var universeSelection = new UniverseSelection( _algorithm, securityService, new DataPermissionManager(), TestGlobals.DataProvider, Resolution.Second); _dataManager = new DataManager(_dataFeed, universeSelection, _algorithm, new TimeKeeper(DateTime.UtcNow, TimeZones.NewYork), MarketHoursDatabase.FromDataFolder(), true, new RegisteredSecurityDataTypesProvider(), new DataPermissionManager()); _resultHandler = new TestResultHandler(); _synchronizer.Initialize(_algorithm, _dataManager); _dataFeed.Initialize(_algorithm, new LiveNodePacket(), _resultHandler, TestGlobals.MapFileProvider, TestGlobals.FactorFileProvider, TestGlobals.DataProvider, _dataManager, _synchronizer, new DataChannelProvider()); _algorithm.SubscriptionManager.SetDataManager(_dataManager); _algorithm.Securities.SetSecurityService(securityService); _algorithm.SetFinishedWarmingUp(); var backtestingTransactionHandler = new BacktestingTransactionHandler(); backtestingTransactionHandler.Initialize(_algorithm, new PaperBrokerage(_algorithm, new LiveNodePacket()), _resultHandler); _algorithm.Transactions.SetOrderProcessor(backtestingTransactionHandler); _algorithm.PostInitialize(); }
public TickGenerator(RandomDataGeneratorSettings settings, TickType[] tickTypes, Security security, IRandomValueGenerator random) { _random = random; _settings = settings; _tickTypes = tickTypes; Security = security; SymbolPropertiesDatabase = SymbolPropertiesDatabase.FromDataFolder(); MarketHoursDatabase = MarketHoursDatabase.FromDataFolder(); if (Symbol.SecurityType.IsOption()) { _priceGenerator = new OptionPriceModelPriceGenerator(security); } else { _priceGenerator = new RandomPriceGenerator(security, random); } }
/// <summary> /// Creates an instance of SymbolData, used internally to calculate capacity /// </summary> /// <param name="symbol">Symbol to calculate capacity for</param> /// <param name="timeZone">Time zone of the data</param> /// <param name="fastTradingVolumeScalingFactor">Penalty for fast trading</param> /// <param name="percentageOfMinuteDollarVolume">Percentage of minute dollar volume to assume as take-able without moving the market</param> public SymbolData( Symbol symbol, DateTimeZone timeZone, IEnumerable <OrderEvent> orderEvents, CashBook cashBook, SymbolPropertiesDatabase spdb, decimal fastTradingVolumeScalingFactor, decimal percentageOfMinuteDollarVolume) { TimeZone = timeZone; _symbol = symbol; _orderEvents = orderEvents.GetEnumerator(); _fastTradingVolumeScalingFactor = (double)fastTradingVolumeScalingFactor; _percentageOfMinuteDollarVolume = percentageOfMinuteDollarVolume; _quoteCurrency = spdb.GetSymbolProperties(symbol.ID.Market, symbol, symbol.SecurityType, "USD").QuoteCurrency; _cashBook = cashBook; }
public void DoesNotLoopEndlesslyIfGetCashBalanceAlwaysThrows() { // simulate connect failure var ib = new Mock <IBrokerage>(); ib.Setup(m => m.GetCashBalance()).Callback(() => { throw new Exception("Connection error in CashBalance"); }); ib.Setup(m => m.IsConnected).Returns(false); var brokerage = ib.Object; Assert.IsFalse(brokerage.IsConnected); var algorithm = new QCAlgorithm(); var marketHoursDatabase = MarketHoursDatabase.FromDataFolder(); var symbolPropertiesDataBase = SymbolPropertiesDatabase.FromDataFolder(); var securityService = new SecurityService(algorithm.Portfolio.CashBook, marketHoursDatabase, symbolPropertiesDataBase, algorithm); algorithm.Securities.SetSecurityService(securityService); algorithm.SetLiveMode(true); var transactionHandler = new TestBrokerageTransactionHandler(); transactionHandler.Initialize(algorithm, brokerage, new TestResultHandler()); // Advance current time UTC so cash sync is performed transactionHandler.TestCurrentTimeUtc = transactionHandler.TestCurrentTimeUtc.AddDays(2); try { while (true) { transactionHandler.ProcessSynchronousEvents(); Assert.IsFalse(brokerage.IsConnected); Thread.Sleep(1000); } } catch (Exception exception) { // expect exception from ProcessSynchronousEvents when max attempts reached Assert.That(exception.Message.Contains("maximum number of attempts")); } }
public Option AddChineseOption(string underlying, Resolution resolution = Resolution.Minute, string market = null, bool fillDataForward = true, decimal leverage = 0m) { if (market == null) { if (!BrokerageModel.DefaultMarkets.TryGetValue(SecurityType.Option, out market)) { throw new Exception("No default market set for security type: " + SecurityType.Option); } } Symbol canonicalSymbol; var alias = "?" + underlying; if (!SymbolCache.TryGetSymbol(alias, out canonicalSymbol)) { //canonicalSymbol = QuantConnect.Symbol.Create(underlying, SecurityType.Option, market, alias); canonicalSymbol = QuantConnect.Symbol.CreateOption(underlying, market, OptionStyle.European, default(OptionRight), 0, SecurityIdentifier.DefaultDate, alias); } var marketHoursEntry = MarketHoursDatabase.FromDataFolder().GetEntry(market, underlying, SecurityType.Option); var symbolProperties = SymbolPropertiesDatabase.FromDataFolder().GetSymbolProperties(market, underlying, SecurityType.Option, CashBook.AccountCurrency); var canonicalSecurity = (Option)SecurityManager.CreateSecurity(new List <Type>() { typeof(ZipEntryName) }, Portfolio, SubscriptionManager, marketHoursEntry.ExchangeHours, marketHoursEntry.DataTimeZone, symbolProperties, SecurityInitializer, canonicalSymbol, resolution, fillDataForward, leverage, false, false, false, LiveMode, true, false); canonicalSecurity.IsTradable = false; Securities.Add(canonicalSecurity); // add this security to the user defined universe Universe universe; if (!UniverseManager.TryGetValue(canonicalSymbol, out universe)) { var settings = new UniverseSettings(resolution, leverage, true, false, TimeSpan.Zero); universe = new OptionChainUniverse(canonicalSecurity, settings, SubscriptionManager, SecurityInitializer); UniverseManager.Add(canonicalSymbol, universe); } return(canonicalSecurity); }
private PortfolioLooperAlgorithm CreateAlgorithm(IEnumerable <Order> orders) { var algorithm = new PortfolioLooperAlgorithm(100000m, orders); // Create MHDB and Symbol properties DB instances for the DataManager var marketHoursDatabase = MarketHoursDatabase.FromDataFolder(); var symbolPropertiesDataBase = SymbolPropertiesDatabase.FromDataFolder(); var dataPermissionManager = new DataPermissionManager(); var dataManager = new DataManager(new QuantConnect.Report.MockDataFeed(), new UniverseSelection( algorithm, new SecurityService(algorithm.Portfolio.CashBook, marketHoursDatabase, symbolPropertiesDataBase, algorithm, RegisteredSecurityDataTypesProvider.Null, new SecurityCacheProvider(algorithm.Portfolio)), dataPermissionManager), algorithm, algorithm.TimeKeeper, marketHoursDatabase, false, RegisteredSecurityDataTypesProvider.Null, dataPermissionManager); var securityService = new SecurityService(algorithm.Portfolio.CashBook, marketHoursDatabase, symbolPropertiesDataBase, algorithm, RegisteredSecurityDataTypesProvider.Null, new SecurityCacheProvider(algorithm.Portfolio)); var transactions = new BacktestingTransactionHandler(); var results = new BacktestingResultHandler(); // Initialize security services and other properties so that we // don't get null reference exceptions during our re-calculation algorithm.Securities.SetSecurityService(securityService); algorithm.SubscriptionManager.SetDataManager(dataManager); return(algorithm); }
protected virtual Option CreateOptionChainSecurity(QCAlgorithmFramework algorithm, Symbol symbol, UniverseSettings settings, ISecurityInitializer initializer) { algorithm.Log($"OptionUniverseSelectionModel.CreateOptionChainSecurity({algorithm.UtcTime}, {symbol}): Creating Option Chain Security"); var market = symbol.ID.Market; var underlying = symbol.Underlying; var marketHoursEntry = MarketHoursDatabase.FromDataFolder() .GetEntry(market, underlying, SecurityType.Option); var symbolProperties = SymbolPropertiesDatabase.FromDataFolder() .GetSymbolProperties(market, underlying, SecurityType.Option, CashBook.AccountCurrency); var optionChain = (Option)SecurityManager.CreateSecurity(typeof(ZipEntryName), algorithm.Portfolio, algorithm.SubscriptionManager, marketHoursEntry.ExchangeHours, marketHoursEntry.DataTimeZone, symbolProperties, initializer, symbol, settings.Resolution, settings.FillForward, settings.Leverage, settings.ExtendedMarketHours, false, false, algorithm.LiveMode, false, false); return(optionChain); }
public void LoadsMinimumOrderSize() { var db = SymbolPropertiesDatabase.FromDataFolder(); var bitfinexSymbol = Symbol.Create("BTCUSD", SecurityType.Crypto, Market.Bitfinex); var bitfinexSymbolProperties = db.GetSymbolProperties(bitfinexSymbol.ID.Market, bitfinexSymbol, bitfinexSymbol.SecurityType, "USD"); var binanceSymbol = Symbol.Create("BTCEUR", SecurityType.Crypto, Market.Binance); var binanceSymbolProperties = db.GetSymbolProperties(binanceSymbol.ID.Market, binanceSymbol, binanceSymbol.SecurityType, "EUR"); var gdaxSymbol = Symbol.Create("BTCGBP", SecurityType.Crypto, Market.GDAX); var gdaxSymbolProperties = db.GetSymbolProperties(gdaxSymbol.ID.Market, gdaxSymbol, gdaxSymbol.SecurityType, "GBP"); var krakenSymbol = Symbol.Create("BTCCAD", SecurityType.Crypto, Market.Kraken); var krakenSymbolProperties = db.GetSymbolProperties(krakenSymbol.ID.Market, krakenSymbol, krakenSymbol.SecurityType, "CAD"); Assert.AreEqual(bitfinexSymbolProperties.MinimumOrderSize, 0.00006m); Assert.AreEqual(binanceSymbolProperties.MinimumOrderSize, 10m); // in quote currency, MIN_NOTIONAL Assert.AreEqual(gdaxSymbolProperties.MinimumOrderSize, 0.0001m); Assert.AreEqual(krakenSymbolProperties.MinimumOrderSize, 0.0001m); }
private Tuple <QCAlgorithm, DataManager> GetAlgorithmAndDataManager() { var algorithm = new QCAlgorithm(); var marketHoursDatabase = MarketHoursDatabase.FromDataFolder(); var symbolPropertiesDatabase = SymbolPropertiesDatabase.FromDataFolder(); var dataPermissionManager = new DataPermissionManager(); var dataManager = new DataManager( new MockDataFeed(), new UniverseSelection( algorithm, new SecurityService( algorithm.Portfolio.CashBook, marketHoursDatabase, symbolPropertiesDatabase, algorithm, RegisteredSecurityDataTypesProvider.Null, new SecurityCacheProvider(algorithm.Portfolio)), dataPermissionManager, new DefaultDataProvider()), algorithm, algorithm.TimeKeeper, marketHoursDatabase, false, RegisteredSecurityDataTypesProvider.Null, dataPermissionManager); var securityService = new SecurityService( algorithm.Portfolio.CashBook, marketHoursDatabase, symbolPropertiesDatabase, algorithm, RegisteredSecurityDataTypesProvider.Null, new SecurityCacheProvider(algorithm.Portfolio)); algorithm.SubscriptionManager.SetDataManager(dataManager); algorithm.Securities.SetSecurityService(securityService); return(Tuple.Create(algorithm, dataManager)); }