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));
}
