private void SetPortfolioConstruction(Language language, QCAlgorithm algorithm, PortfolioBias bias = PortfolioBias.LongShort)
{
algorithm.SetPortfolioConstruction(new AccumulativeInsightPortfolioConstructionModel((Func <DateTime, DateTime>)null, bias));
if (language == Language.Python)
{
using (Py.GIL())
{
var name = nameof(AccumulativeInsightPortfolioConstructionModel);
var instance = Py.Import(name).GetAttr(name).Invoke(((object)null).ToPython(), ((int)bias).ToPython());
var model = new PortfolioConstructionModelPythonWrapper(instance);
algorithm.SetPortfolioConstruction(model);
}
}
foreach (var kvp in _algorithm.Portfolio)
{
kvp.Value.SetHoldings(kvp.Value.Price, 0);
}
_algorithm.Portfolio.SetCash(_startingCash);
SetUtcTime(new DateTime(2018, 7, 31));
var changes = SecurityChangesTests.AddedNonInternal(_algorithm.Securities.Values.ToArray());
algorithm.PortfolioConstruction.OnSecuritiesChanged(_algorithm, changes);
}
private void SetPortfolioConstruction(Language language)
{
_algorithm.SetCurrentSlice(null);
IPortfolioConstructionModel model;
if (language == Language.CSharp)
{
model = new EqualWeightingAlphaStreamsPortfolioConstructionModel();
}
else
{
throw new NotImplementedException($"{language} not implemented");
}
_algorithm.SetPortfolioConstruction(model);
foreach (var kvp in _algorithm.Portfolio)
{
kvp.Value.SetHoldings(kvp.Value.Price, 0);
}
_algorithm.Portfolio.SetCash(100000);
SetUtcTime(new DateTime(2018, 4, 5));
var changes = SecurityChangesTests.AddedNonInternal(_algorithm.Securities.Values.ToArray());
_algorithm.PortfolioConstruction.OnSecuritiesChanged(_algorithm, changes);
}
private void SetPortfolioConstruction(Language language, QCAlgorithm algorithm, dynamic paramenter = null)
{
paramenter = paramenter ?? Resolution.Daily;
algorithm.SetPortfolioConstruction(new ConfidenceWeightedPortfolioConstructionModel(paramenter));
if (language == Language.Python)
{
using (Py.GIL())
{
var name = nameof(ConfidenceWeightedPortfolioConstructionModel);
var instance = Py.Import(name).GetAttr(name).Invoke(((object)paramenter).ToPython());
var model = new PortfolioConstructionModelPythonWrapper(instance);
algorithm.SetPortfolioConstruction(model);
}
}
foreach (var kvp in _algorithm.Portfolio)
{
kvp.Value.SetHoldings(kvp.Value.Price, 0);
}
_algorithm.Portfolio.SetCash(_startingCash);
SetUtcTime(new DateTime(2018, 7, 31));
var changes = SecurityChangesTests.AddedNonInternal(_algorithm.Securities.Values.ToArray());
algorithm.PortfolioConstruction.OnSecuritiesChanged(_algorithm, changes);
}
public void DelistedSecurityEmitsFlatTargetWithNewInsights(Language language, InsightDirection direction)
{
SetPortfolioConstruction(language, _algorithm);
var insights = new[] { GetInsight(Symbols.SPY, InsightDirection.Down, _algorithm.UtcTime) };
var targets = _algorithm.PortfolioConstruction.CreateTargets(_algorithm, insights).ToList();
Assert.AreEqual(1, targets.Count);
// Removing SPY should clear the key in the insight collection
var changes = SecurityChangesTests.RemovedNonInternal(_algorithm.Securities[Symbols.SPY]);
_algorithm.PortfolioConstruction.OnSecuritiesChanged(_algorithm, changes);
var amount = _algorithm.Portfolio.TotalPortfolioValue * (decimal)Confidence;
var expectedTargets = _algorithm.Securities.Select(x =>
{
// Expected target quantity for SPY is zero, since it will be removed
var quantity = x.Key.Value == "SPY" ? 0 : (int)direction
* Math.Floor(amount * (1 - _algorithm.Settings.FreePortfolioValuePercentage)
/ x.Value.Price);
return(new PortfolioTarget(x.Key, quantity));
});
// Do no include SPY in the insights
insights = _algorithm.Securities.Keys.Where(x => x.Value != "SPY")
.Select(x => GetInsight(x, direction, _algorithm.UtcTime)).ToArray();
// Create target from an empty insights array
var actualTargets = _algorithm.PortfolioConstruction.CreateTargets(_algorithm, insights);
AssertTargets(expectedTargets, actualTargets);
}
public void EnsureCurrencyDataFeedChecksSecurityChangesForSecurity()
{
const int quantity = 100;
const decimal conversionRate = 1 / 100m;
var cash = new Cash("JPY", quantity, conversionRate);
var cashBook = new CashBook();
cashBook.Add("JPY", cash);
var subscriptions = new SubscriptionManager();
var dataManager = new DataManagerStub(TimeKeeper);
subscriptions.SetDataManager(dataManager);
var abcConfig = subscriptions.Add(Symbols.SPY, Resolution.Minute, TimeZone, TimeZone);
var securities = new SecurityManager(TimeKeeper);
securities.Add(
Symbols.SPY,
new Security(
SecurityExchangeHours,
abcConfig,
new Cash(cashBook.AccountCurrency, 0, 1m),
SymbolProperties.GetDefault(cashBook.AccountCurrency),
ErrorCurrencyConverter.Instance,
RegisteredSecurityDataTypesProvider.Null,
new SecurityCache()
)
);
var usdjpy = new Security(Symbols.USDJPY, SecurityExchangeHours, new Cash("JPY", 0, 0), SymbolProperties.GetDefault("JPY"), ErrorCurrencyConverter.Instance, RegisteredSecurityDataTypesProvider.Null, new SecurityCache());
var changes = SecurityChangesTests.CreateNonInternal(new[] { usdjpy }, Enumerable.Empty <Security>());
var addedSecurities = cash.EnsureCurrencyDataFeed(securities, subscriptions, MarketMap, changes, dataManager.SecurityService, cashBook.AccountCurrency);
// the security exists in SecurityChanges so it is NOT added to the security manager or subscriptions
// this security will be added by the algorithm manager
Assert.True(addedSecurities == null || addedSecurities.Count == 0);
}
public void OrdersAreNotSubmittedWhenNoTargetsToExecute(Language language)
{
var actualOrdersSubmitted = new List <SubmitOrderRequest>();
var orderProcessor = new Mock <IOrderProcessor>();
orderProcessor.Setup(m => m.Process(It.IsAny <SubmitOrderRequest>()))
.Returns((OrderTicket)null)
.Callback((OrderRequest request) => actualOrdersSubmitted.Add((SubmitOrderRequest)request));
var algorithm = new QCAlgorithm();
algorithm.SetPandasConverter();
algorithm.SubscriptionManager.SetDataManager(new DataManagerStub(algorithm));
algorithm.Transactions.SetOrderProcessor(orderProcessor.Object);
var model = GetExecutionModel(language);
algorithm.SetExecution(model);
var changes = SecurityChangesTests.CreateNonInternal(Enumerable.Empty <Security>(), Enumerable.Empty <Security>());
model.OnSecuritiesChanged(algorithm, changes);
model.Execute(algorithm, new IPortfolioTarget[0]);
Assert.AreEqual(0, actualOrdersSubmitted.Count);
}
public void HandlesMultipleCustomDataOfSameTypeWithDifferentSymbols()
{
var symbol1 = Symbol.Create("SCF/CBOE_VX1_EW", SecurityType.Base, Market.USA);
var symbol2 = Symbol.Create("SCF/CBOE_VX2_EW", SecurityType.Base, Market.USA);
var subscriptionDataConfig1 = new SubscriptionDataConfig(
typeof(UnlinkedData), symbol1, Resolution.Daily, TimeZones.Utc, TimeZones.Utc, true, true, false, isCustom: true);
var subscriptionDataConfig2 = new SubscriptionDataConfig(
typeof(UnlinkedData), symbol2, Resolution.Daily, TimeZones.Utc, TimeZones.Utc, true, true, false, isCustom: true);
var security1 = new Security(
SecurityExchangeHours.AlwaysOpen(TimeZones.Utc),
subscriptionDataConfig1,
new Cash(Currencies.USD, 0, 1m),
SymbolProperties.GetDefault(Currencies.USD),
ErrorCurrencyConverter.Instance,
RegisteredSecurityDataTypesProvider.Null,
new SecurityCache()
);
var security2 = new Security(
SecurityExchangeHours.AlwaysOpen(TimeZones.Utc),
subscriptionDataConfig1,
new Cash(Currencies.USD, 0, 1m),
SymbolProperties.GetDefault(Currencies.USD),
ErrorCurrencyConverter.Instance,
RegisteredSecurityDataTypesProvider.Null,
new SecurityCache()
);
var timeSlice = _timeSliceFactory.Create(DateTime.UtcNow,
new List <DataFeedPacket>
{
new DataFeedPacket(security1, subscriptionDataConfig1, new List <BaseData> {
new UnlinkedData {
Symbol = symbol1, Time = DateTime.UtcNow.Date, Value = 15
}
}),
new DataFeedPacket(security2, subscriptionDataConfig2, new List <BaseData> {
new UnlinkedData {
Symbol = symbol2, Time = DateTime.UtcNow.Date, Value = 20
}
}),
},
SecurityChangesTests.CreateNonInternal(Enumerable.Empty <Security>(), Enumerable.Empty <Security>()),
new Dictionary <Universe, BaseDataCollection>());
Assert.AreEqual(2, timeSlice.CustomData.Count);
var data1 = timeSlice.CustomData[0].Data[0];
var data2 = timeSlice.CustomData[1].Data[0];
Assert.IsInstanceOf(typeof(UnlinkedData), data1);
Assert.IsInstanceOf(typeof(UnlinkedData), data2);
Assert.AreEqual(symbol1, data1.Symbol);
Assert.AreEqual(symbol2, data2.Symbol);
Assert.AreEqual(15, data1.Value);
Assert.AreEqual(20, data2.Value);
}
public void InsightsGenerationTest(Language language)
{
IAlphaModel model;
if (!TryCreateModel(language, out model))
{
Assert.Ignore($"Ignore {GetType().Name}: Could not create {language} model.");
}
// Set the alpha model
Algorithm.SetAlpha(model);
Algorithm.SetUniverseSelection(new ManualUniverseSelectionModel());
var changes = SecurityChangesTests.CreateNonInternal(AddedSecurities, RemovedSecurities);
Algorithm.OnFrameworkSecuritiesChanged(changes);
var actualInsights = new List <Insight>();
Algorithm.InsightsGenerated += (s, e) => actualInsights.AddRange(e.Insights);
var expectedInsights = ExpectedInsights().ToList();
var consolidators = Algorithm.Securities.SelectMany(kvp => kvp.Value.Subscriptions).SelectMany(x => x.Consolidators);
var slices = CreateSlices();
foreach (var slice in slices.ToList())
{
Algorithm.SetDateTime(slice.Time);
foreach (var symbol in slice.Keys)
{
var data = slice[symbol];
Algorithm.Securities[symbol].SetMarketPrice(data);
foreach (var consolidator in consolidators)
{
consolidator.Update(data);
}
}
Algorithm.OnFrameworkData(slice);
}
Assert.AreEqual(expectedInsights.Count, actualInsights.Count);
for (var i = 0; i < actualInsights.Count; i++)
{
var actual = actualInsights[i];
var expected = expectedInsights[i];
Assert.AreEqual(expected.Symbol, actual.Symbol);
Assert.AreEqual(expected.Type, actual.Type);
Assert.AreEqual(expected.Direction, actual.Direction);
Assert.AreEqual(expected.Period, actual.Period);
Assert.AreEqual(expected.Magnitude, actual.Magnitude);
Assert.AreEqual(expected.Confidence, actual.Confidence);
}
}
public void FillsOnTradesOnlyRespectingExchangeOpen(Language language, int expectedOrdersSubmitted, decimal expectedTotalQuantity, bool exchangeOpen)
{
var actualOrdersSubmitted = new List <SubmitOrderRequest>();
var time = new DateTime(2018, 8, 2, 0, 0, 0);
if (exchangeOpen)
{
time = time.AddHours(14);
}
var algorithm = new QCAlgorithm();
algorithm.SetPandasConverter();
algorithm.SubscriptionManager.SetDataManager(new DataManagerStub(algorithm));
algorithm.SetDateTime(time.AddMinutes(5));
var security = algorithm.AddEquity(Symbols.AAPL.Value);
security.SetMarketPrice(new TradeBar {
Value = 250
});
algorithm.SetFinishedWarmingUp();
var orderProcessor = new Mock <IOrderProcessor>();
orderProcessor.Setup(m => m.Process(It.IsAny <SubmitOrderRequest>()))
.Returns((SubmitOrderRequest request) => new OrderTicket(algorithm.Transactions, request))
.Callback((OrderRequest request) => actualOrdersSubmitted.Add((SubmitOrderRequest)request));
orderProcessor.Setup(m => m.GetOpenOrders(It.IsAny <Func <Order, bool> >()))
.Returns(new List <Order>());
algorithm.Transactions.SetOrderProcessor(orderProcessor.Object);
var model = GetExecutionModel(language);
algorithm.SetExecution(model);
var changes = SecurityChangesTests.CreateNonInternal(new[] { security }, Enumerable.Empty <Security>());
model.OnSecuritiesChanged(algorithm, changes);
var targets = new IPortfolioTarget[] { new PortfolioTarget(Symbols.AAPL, 10) };
model.Execute(algorithm, targets);
Assert.AreEqual(expectedOrdersSubmitted, actualOrdersSubmitted.Count);
Assert.AreEqual(expectedTotalQuantity, actualOrdersSubmitted.Sum(x => x.Quantity));
if (actualOrdersSubmitted.Count == 1)
{
var request = actualOrdersSubmitted[0];
Assert.AreEqual(expectedTotalQuantity, request.Quantity);
Assert.AreEqual(algorithm.UtcTime, request.Time);
}
}
public void MultipleAlphaPositionAggregation(Language language, decimal totalPortfolioValueAlpha1, decimal totalPortfolioValueAlpha2, decimal freePortfolioValue)
{
SetPortfolioConstruction(language);
_algorithm.Settings.FreePortfolioValue = freePortfolioValue;
var alpha1 = _algorithm.AddData <AlphaStreamsPortfolioState>("9fc8ef73792331b11dbd5429a");
var alpha2 = _algorithm.AddData <AlphaStreamsPortfolioState>("623b06b231eb1cc1aa3643a46");
_algorithm.OnFrameworkSecuritiesChanged(SecurityChangesTests.AddedNonInternal(alpha1, alpha2));
var symbol = alpha1.Symbol;
var symbol2 = alpha2.Symbol;
var data = _algorithm.History <AlphaStreamsPortfolioState>(symbol, TimeSpan.FromDays(1)).Last();
AddSecurities(_algorithm, data);
data.TotalPortfolioValue = totalPortfolioValueAlpha1;
var position = data.PositionGroups.Single().Positions.Single();
var data2 = (AlphaStreamsPortfolioState)data.Clone();
data2.Symbol = symbol2;
data2.TotalPortfolioValue = totalPortfolioValueAlpha2;
data2.PositionGroups =
new List <PositionGroupState>
{
new PositionGroupState {
Positions =
new List <PositionState>
{
new PositionState
{
Quantity = position.Quantity * -10,
Symbol = position.Symbol,
UnitQuantity = 1
}
}
}
};
_algorithm.SetCurrentSlice(new Slice(_algorithm.UtcTime, new List <BaseData> {
data, data2
}));
var targets = _algorithm.PortfolioConstruction.CreateTargets(_algorithm, Array.Empty <Insight>()).ToList();
Assert.AreEqual(1, targets.Count);
Assert.AreEqual(position.Symbol, targets.Single().Symbol);
var tvpPerAlpha = (_algorithm.Portfolio.TotalPortfolioValue - freePortfolioValue) * 0.5m;
var alpha1Weight = tvpPerAlpha / data.TotalPortfolioValue;
var alpha2Weight = tvpPerAlpha / data2.TotalPortfolioValue;
Assert.AreEqual((position.Quantity * alpha1Weight).DiscretelyRoundBy(1, MidpointRounding.ToZero)
+ (position.Quantity * -10m * alpha2Weight).DiscretelyRoundBy(1, MidpointRounding.ToZero),
targets.Single().Quantity);
}
public void PortfolioBiasIsRespected(Language language, PortfolioBias bias)
{
SetPortfolioConstruction(language, _algorithm, bias);
var now = new DateTime(2018, 7, 31);
SetUtcTime(now.ConvertFromUtc(_algorithm.TimeZone));
var appl = _algorithm.AddEquity("AAPL");
appl.SetMarketPrice(new Tick(now, appl.Symbol, 10, 10));
var spy = _algorithm.AddEquity("SPY");
spy.SetMarketPrice(new Tick(now, spy.Symbol, 20, 20));
var ibm = _algorithm.AddEquity("IBM");
ibm.SetMarketPrice(new Tick(now, ibm.Symbol, 30, 30));
var aig = _algorithm.AddEquity("AIG");
aig.SetMarketPrice(new Tick(now, aig.Symbol, 30, 30));
var qqq = _algorithm.AddEquity("QQQ");
qqq.SetMarketPrice(new Tick(now, qqq.Symbol, 30, 30));
var insights = new[]
{
new Insight(now, appl.Symbol, TimeSpan.FromDays(1), InsightType.Price, InsightDirection.Up, 0.1d, null),
new Insight(now, spy.Symbol, TimeSpan.FromDays(1), InsightType.Price, InsightDirection.Down, -0.1d, null),
new Insight(now, ibm.Symbol, TimeSpan.FromDays(1), InsightType.Price, InsightDirection.Down, 0d, null),
new Insight(now, aig.Symbol, TimeSpan.FromDays(1), InsightType.Price, InsightDirection.Down, -0.1d, null),
new Insight(now, qqq.Symbol, TimeSpan.FromDays(1), InsightType.Price, InsightDirection.Up, 0.1d, null)
};
_algorithm.PortfolioConstruction.OnSecuritiesChanged(_algorithm, SecurityChangesTests.AddedNonInternal(appl, spy, ibm, aig, qqq));
var createdValidTarget = false;
foreach (var target in _algorithm.PortfolioConstruction.CreateTargets(_algorithm, insights))
{
QuantConnect.Logging.Log.Trace($"{target.Symbol}: {target.Quantity}");
if (target.Quantity == 0)
{
continue;
}
createdValidTarget = true;
Assert.AreEqual(Math.Sign((int)bias), Math.Sign(target.Quantity));
}
Assert.IsTrue(createdValidTarget);
}
public void OnSecuritiesChangeDoesNotThrow(
Language language,
double[] historicalPrices,
MarketDataType marketDataType)
{
var time = new DateTime(2018, 8, 2, 16, 0, 0);
Func <double, int, BaseData> func = (x, i) =>
{
var price = Convert.ToDecimal(x);
switch (marketDataType)
{
case MarketDataType.TradeBar:
return(new TradeBar(time.AddMinutes(i), Symbols.AAPL, price, price, price, price, 100m));
case MarketDataType.QuoteBar:
var bar = new Bar(price, price, price, price);
return(new QuoteBar(time.AddMinutes(i), Symbols.AAPL, bar, 10m, bar, 10m));
default:
throw new ArgumentException($"Invalid MarketDataType: {marketDataType}");
}
};
var historyProvider = new Mock <IHistoryProvider>();
historyProvider.Setup(m => m.GetHistory(It.IsAny <IEnumerable <HistoryRequest> >(), It.IsAny <DateTimeZone>()))
.Returns(historicalPrices.Select((x, i) => new Slice(time.AddMinutes(i), new List <BaseData> {
func(x, i)
})));
var algorithm = new QCAlgorithm();
algorithm.SetPandasConverter();
algorithm.SetHistoryProvider(historyProvider.Object);
algorithm.SubscriptionManager.SetDataManager(new DataManagerStub(algorithm));
algorithm.SetDateTime(time.AddMinutes(5));
var security = algorithm.AddEquity(Symbols.AAPL.Value);
security.SetMarketPrice(new TradeBar {
Value = 250
});
algorithm.SetFinishedWarmingUp();
var model = GetExecutionModel(language);
algorithm.SetExecution(model);
var changes = SecurityChangesTests.CreateNonInternal(new[] { security }, Enumerable.Empty <Security>());
Assert.DoesNotThrow(() => model.OnSecuritiesChanged(algorithm, changes));
}
public void AddedSecuritiesTest(Language language)
{
IAlphaModel model;
if (!TryCreateModel(language, out model))
{
Assert.Ignore($"Ignore {GetType().Name}: Could not create {language} model.");
}
var changes = SecurityChangesTests.CreateNonInternal(AddedSecurities, RemovedSecurities);
Assert.DoesNotThrow(() => model.OnSecuritiesChanged(Algorithm, changes));
}
protected void SetPortfolioConstruction(Language language, PortfolioBias bias)
{
var model = GetPortfolioConstructionModel(language, Resolution.Daily, bias);
_algorithm.SetPortfolioConstruction(model);
foreach (var kvp in _algorithm.Portfolio)
{
kvp.Value.SetHoldings(kvp.Value.Price, 0);
}
var changes = SecurityChangesTests.AddedNonInternal(_algorithm.Securities.Values.ToArray());
_algorithm.PortfolioConstruction.OnSecuritiesChanged(_algorithm, changes);
}
public void HandlesTicks_ExpectInOrderWithNoDuplicates()
{
var subscriptionDataConfig = new SubscriptionDataConfig(
typeof(Tick),
Symbols.EURUSD,
Resolution.Tick,
TimeZones.Utc,
TimeZones.Utc,
true,
true,
false);
var security = new Security(
SecurityExchangeHours.AlwaysOpen(TimeZones.Utc),
subscriptionDataConfig,
new Cash(Currencies.USD, 0, 1m),
SymbolProperties.GetDefault(Currencies.USD),
ErrorCurrencyConverter.Instance,
RegisteredSecurityDataTypesProvider.Null,
new SecurityCache()
);
DateTime refTime = DateTime.UtcNow;
Tick[] rawTicks = Enumerable
.Range(0, 10)
.Select(i => new Tick(refTime.AddSeconds(i), Symbols.EURUSD, 1.3465m, 1.34652m))
.ToArray();
IEnumerable <TimeSlice> timeSlices = rawTicks.Select(t => _timeSliceFactory.Create(
t.Time,
new List <DataFeedPacket> {
new DataFeedPacket(security, subscriptionDataConfig, new List <BaseData>()
{
t
})
},
SecurityChangesTests.CreateNonInternal(Enumerable.Empty <Security>(), Enumerable.Empty <Security>()),
new Dictionary <Universe, BaseDataCollection>()));
Tick[] timeSliceTicks = timeSlices.SelectMany(ts => ts.Slice.Ticks.Values.SelectMany(x => x)).ToArray();
Assert.AreEqual(rawTicks.Length, timeSliceTicks.Length);
for (int i = 0; i < rawTicks.Length; i++)
{
Assert.IsTrue(Compare(rawTicks[i], timeSliceTicks[i]));
}
}
public void DailySampleValueBasedOnMarketHour(bool extendedMarketHoursEnabled)
{
var referenceDate = new DateTime(2020, 11, 25);
var resultHandler = new LiveTradingResultHandler();
resultHandler.Initialize(new LiveNodePacket(),
new QuantConnect.Messaging.Messaging(),
new Api.Api(),
new BacktestingTransactionHandler());
var algo = new AlgorithmStub(createDataManager: false);
algo.SetFinishedWarmingUp();
var dataManager = new DataManagerStub(new TestDataFeed(), algo);
algo.SubscriptionManager.SetDataManager(dataManager);
var aapl = algo.AddEquity("AAPL", extendedMarketHours: extendedMarketHoursEnabled);
algo.PostInitialize();
resultHandler.SetAlgorithm(algo, 100000);
resultHandler.OnSecuritiesChanged(SecurityChangesTests.AddedNonInternal(aapl));
// Add values during market hours, should always update
algo.Portfolio.CashBook["USD"].AddAmount(1000);
algo.Portfolio.InvalidateTotalPortfolioValue();
resultHandler.Sample(referenceDate.AddHours(15));
Assert.IsTrue(resultHandler.Charts.ContainsKey("Strategy Equity"));
Assert.AreEqual(1, resultHandler.Charts["Strategy Equity"].Series["Equity"].Values.Count);
var currentEquityValue = resultHandler.Charts["Strategy Equity"].Series["Equity"].Values.Last().y;
Assert.AreEqual(101000, currentEquityValue);
// Add value to portfolio, see if portfolio updates with new sample
// will be changed to 'extendedMarketHoursEnabled' = true
algo.Portfolio.CashBook["USD"].AddAmount(10000);
algo.Portfolio.InvalidateTotalPortfolioValue();
resultHandler.Sample(referenceDate.AddHours(22));
Assert.AreEqual(2, resultHandler.Charts["Strategy Equity"].Series["Equity"].Values.Count);
currentEquityValue = resultHandler.Charts["Strategy Equity"].Series["Equity"].Values.Last().y;
Assert.AreEqual(extendedMarketHoursEnabled ? 111000 : 101000, currentEquityValue);
resultHandler.Exit();
}
protected void SetPortfolioConstruction(Language language, dynamic paramenter = null)
{
var model = GetPortfolioConstructionModel(language, paramenter ?? Resolution.Daily);
Algorithm.SetPortfolioConstruction(model);
foreach (var kvp in Algorithm.Portfolio)
{
kvp.Value.SetHoldings(kvp.Value.Price, 0);
}
Algorithm.Portfolio.SetCash(StartingCash);
SetUtcTime(new DateTime(2018, 7, 31));
var changes = SecurityChangesTests.AddedNonInternal(Algorithm.Securities.Values.ToArray());
Algorithm.PortfolioConstruction.OnSecuritiesChanged(Algorithm, changes);
}
public void RemovedSecuritiesTest(Language language)
{
IAlphaModel model;
if (!TryCreateModel(language, out model))
{
Assert.Ignore($"Ignore {GetType().Name}: Could not create {language} model.");
}
var removedSecurities = Algorithm.Securities.Values;
// We have to add some security if we then want to remove it, that's why we cannot use here
// RemovedSecurities, because it doesn't contain any security
var changes = SecurityChangesTests.CreateNonInternal(removedSecurities, AddedSecurities);
Assert.DoesNotThrow(() => model.OnSecuritiesChanged(Algorithm, changes));
}
public override void DelistedSecurityEmitsFlatTargetWithNewInsights(Language language, InsightDirection direction)
{
SetPortfolioConstruction(language);
var insights = new[] { GetInsight(Symbols.SPY, InsightDirection.Down, Algorithm.UtcTime) };
var targets = Algorithm.PortfolioConstruction.CreateTargets(Algorithm, insights).ToList();
Assert.AreEqual(1, targets.Count);
// Removing SPY should clear the key in the insight collection
var changes = SecurityChangesTests.RemovedNonInternal(Algorithm.Securities[Symbols.SPY]);
Algorithm.PortfolioConstruction.OnSecuritiesChanged(Algorithm, changes);
// Since we have 3 B, 2 T and 1 X, each security in each sector will get
// B => .166%, T => .25, X => 0% (removed)
var sectorCount = 2;
var groupedBySector = Algorithm.Securities
.Where(pair => pair.Value.Fundamentals?.CompanyReference?.IndustryTemplateCode != null)
.GroupBy(pair => pair.Value.Fundamentals.CompanyReference.IndustryTemplateCode);
var expectedTargets = new List <PortfolioTarget>();
foreach (var securities in groupedBySector)
{
var list = securities.ToList();
var amount = Algorithm.Portfolio.TotalPortfolioValue / list.Count / sectorCount *
(1 - Algorithm.Settings.FreePortfolioValuePercentage);
expectedTargets.AddRange(list
.Select(x => new PortfolioTarget(x.Key, x.Key.Value == "SPY" ? 0
: (int)direction * Math.Floor(amount / x.Value.Price))));
}
// Do no include SPY in the insights
insights = Algorithm.Securities.Keys.Where(x => x.Value != "SPY")
.Select(x => GetInsight(x, direction, Algorithm.UtcTime)).ToArray();
// Create target from an empty insights array
var actualTargets = Algorithm.PortfolioConstruction.CreateTargets(Algorithm, insights);
Assert.Greater(Algorithm.Securities.Count, expectedTargets.Count);
AssertTargets(expectedTargets, actualTargets);
}
public void DoesNotAddOnEndOfDayEventsIfNotImplemented(Language language)
{
Security security;
IAlgorithm algorithm;
if (language == Language.CSharp)
{
algorithm = new AlgorithmStub();
security = (algorithm as QCAlgorithm).AddEquity("SPY");
}
else
{
algorithm = new AlgorithmPythonWrapper("Test_CustomDataAlgorithm");
algorithm.SubscriptionManager.SetDataManager(new DataManagerStub(algorithm));
security = algorithm.AddSecurity(SecurityType.Equity,
"SPY",
Resolution.Daily,
Market.USA,
false,
1,
false);
}
var realTimeHandler = new TestBacktestingRealTimeHandler();
realTimeHandler.Setup(algorithm,
new AlgorithmNodePacket(PacketType.AlgorithmNode)
{
Language = language
},
_resultHandler,
null,
new TestTimeLimitManager());
Assert.AreEqual(0, realTimeHandler.GetScheduledEventsCount);
realTimeHandler.OnSecuritiesChanged(
SecurityChangesTests.CreateNonInternal(new[] { security }, Enumerable.Empty <Security>()));
Assert.AreEqual(0, realTimeHandler.GetScheduledEventsCount);
realTimeHandler.Exit();
}
public void AddsOnEndOfDayEventsIfImplemented(Language language)
{
Security security;
IAlgorithm algorithm;
if (language == Language.CSharp)
{
algorithm = new TestAlgorithmB();
security = (algorithm as QCAlgorithm).AddEquity("SPY");
}
else
{
algorithm = new AlgorithmPythonWrapper("OnEndOfDayRegressionAlgorithm");
algorithm.SubscriptionManager.SetDataManager(new DataManagerStub(new MockDataFeed(), algorithm));
security = algorithm.AddSecurity(SecurityType.Equity,
"SPY",
Resolution.Daily,
Market.USA,
false,
1,
false);
}
var realTimeHandler = new TestBacktestingRealTimeHandler();
realTimeHandler.Setup(algorithm,
new AlgorithmNodePacket(PacketType.AlgorithmNode)
{
Language = language
},
_resultHandler,
null,
new TestTimeLimitManager());
// Because neither implement EOD() deprecated it should be zero
Assert.AreEqual(0, realTimeHandler.GetScheduledEventsCount);
realTimeHandler.OnSecuritiesChanged(
SecurityChangesTests.CreateNonInternal(new[] { security }, Enumerable.Empty <Security>()));
Assert.AreEqual(1, realTimeHandler.GetScheduledEventsCount);
realTimeHandler.Exit();
}
public void NoRebalanceFunction(Language language)
{
TestPortfolioConstructionModel constructionModel;
if (language == Language.Python)
{
constructionModel = new TestPortfolioConstructionModel();
using (Py.GIL())
{
var func = PythonEngine.ModuleFromString(
"RebalanceFunc",
@"
from datetime import timedelta
def RebalanceFunc():
return None"
).GetAttr("RebalanceFunc");
constructionModel.SetRebalancingFunc(func.Invoke());
}
}
else
{
constructionModel = new TestPortfolioConstructionModel();
}
Assert.IsTrue(constructionModel.IsRebalanceDueWrapper(new DateTime(2020, 1, 1), new Insight[0]));
Assert.IsTrue(constructionModel.IsRebalanceDueWrapper(new DateTime(2020, 1, 2), new Insight[0]));
Assert.IsTrue(constructionModel.IsRebalanceDueWrapper(new DateTime(2020, 1, 3), new Insight[0]));
var security = new Security(Symbols.SPY,
SecurityExchangeHours.AlwaysOpen(DateTimeZone.Utc),
new Cash(Currencies.USD, 1, 1),
SymbolProperties.GetDefault(Currencies.USD),
new IdentityCurrencyConverter(Currencies.USD),
new RegisteredSecurityDataTypesProvider(),
new SecurityCache());
constructionModel.OnSecuritiesChanged(null, SecurityChangesTests.AddedNonInternal(security));
Assert.IsTrue(constructionModel.IsRebalanceDueWrapper(new DateTime(2020, 1, 1), new Insight[0]));
constructionModel.OnSecuritiesChanged(null, SecurityChanges.None);
Assert.IsTrue(constructionModel.IsRebalanceDueWrapper(new DateTime(2020, 1, 1), new Insight[0]));
}
public void SuspiciousTicksAreNotAddedToConsolidatorUpdateData()
{
var symbol = Symbols.SPY;
var subscriptionDataConfig = new SubscriptionDataConfig(
typeof(Tick), symbol, Resolution.Tick, TimeZones.Utc, TimeZones.Utc, true, true, false);
var security = new Security(
SecurityExchangeHours.AlwaysOpen(TimeZones.Utc),
subscriptionDataConfig,
new Cash(Currencies.USD, 0, 1m),
SymbolProperties.GetDefault(Currencies.USD),
ErrorCurrencyConverter.Instance,
RegisteredSecurityDataTypesProvider.Null,
new SecurityCache()
);
var timeSlice = _timeSliceFactory.Create(DateTime.UtcNow,
new List <DataFeedPacket>
{
new DataFeedPacket(security, subscriptionDataConfig, new List <BaseData>
{
new Tick(DateTime.UtcNow, symbol, 280, 0, 0),
new Tick(DateTime.UtcNow, symbol, 500, 0, 0)
{
Suspicious = true
},
new Tick(DateTime.UtcNow, symbol, 281, 0, 0)
})
},
SecurityChangesTests.CreateNonInternal(Enumerable.Empty <Security>(), Enumerable.Empty <Security>()),
new Dictionary <Universe, BaseDataCollection>());
Assert.AreEqual(1, timeSlice.ConsolidatorUpdateData.Count);
var data = timeSlice.ConsolidatorUpdateData[0].Data;
Assert.AreEqual(2, data.Count);
Assert.AreEqual(280, data[0].Value);
Assert.AreEqual(281, data[1].Value);
}
public void WarmsUpProperly()
{
SetUpHistoryProvider();
Algorithm.SetStartDate(2013, 10, 08);
Algorithm.SetUniverseSelection(new ManualUniverseSelectionModel());
// Create a EmaCrossAlphaModel for the test
var model = new TestEmaCrossAlphaModel();
// Set the alpha model
Algorithm.SetAlpha(model);
Algorithm.SetUniverseSelection(new ManualUniverseSelectionModel());
var changes = SecurityChangesTests.CreateNonInternal(AddedSecurities, RemovedSecurities);
Algorithm.OnFrameworkSecuritiesChanged(changes);
// Get the dictionary of macd indicators
var symbolData = model.GetSymbolData();
// Check the symbolData dictionary is not empty
Assert.NotZero(symbolData.Count);
// Check all EmaCross indicators from the alpha are ready and have at least
// one datapoint
foreach (var item in symbolData)
{
var fast = item.Value.Fast;
var slow = item.Value.Slow;
Assert.IsTrue(fast.IsReady);
Assert.NotZero(fast.Samples);
Assert.IsTrue(slow.IsReady);
Assert.NotZero(slow.Samples);
}
ZipCacheProvider.DisposeSafely();
}
public override void DelistedSecurityEmitsFlatTargetWithNewInsights(Language language, InsightDirection direction)
{
SetPortfolioConstruction(language);
if (PortfolioBias != PortfolioBias.LongShort && (int)direction != (int)PortfolioBias)
{
direction = InsightDirection.Flat;
}
var insights = new[] { GetInsight(Symbols.SPY, InsightDirection.Down, Algorithm.UtcTime) };
var targets = Algorithm.PortfolioConstruction.CreateTargets(Algorithm, insights).ToList();
Assert.AreEqual(1, targets.Count);
// Removing SPY should clear the key in the insight collection
var changes = SecurityChangesTests.RemovedNonInternal(Algorithm.Securities[Symbols.SPY]);
Algorithm.PortfolioConstruction.OnSecuritiesChanged(Algorithm, changes);
// Equity will be divided by all securities minus 1, since SPY is already invested and we want to remove it
var amount = Algorithm.Portfolio.TotalPortfolioValue / (decimal)(1 / Weight - 1) *
(1 - Algorithm.Settings.FreePortfolioValuePercentage);
var expectedTargets = Algorithm.Securities.Select(x =>
{
// Expected target quantity for SPY is zero, since it will be removed
var quantity = x.Key.Value == "SPY" ? 0 : (int)direction * Math.Floor(amount / x.Value.Price);
return(new PortfolioTarget(x.Key, quantity));
});
// Do no include SPY in the insights
insights = Algorithm.Securities.Keys.Where(x => x.Value != "SPY")
.Select(x => GetInsight(x, direction, Algorithm.UtcTime)).ToArray();
// Create target from an empty insights array
var actualTargets = Algorithm.PortfolioConstruction.CreateTargets(Algorithm, insights);
AssertTargets(expectedTargets, actualTargets);
}
public void DelistedSecurityEmitsFlatTargetWithoutNewInsights(Language language)
{
SetPortfolioConstruction(language, _algorithm);
var insights = new[] { GetInsight(Symbols.SPY, InsightDirection.Down, _algorithm.UtcTime) };
var targets = _algorithm.PortfolioConstruction.CreateTargets(_algorithm, insights).ToList();
Assert.AreEqual(1, targets.Count);
var changes = SecurityChangesTests.RemovedNonInternal(_algorithm.Securities[Symbols.SPY]);
_algorithm.PortfolioConstruction.OnSecuritiesChanged(_algorithm, changes);
var expectedTargets = new List <IPortfolioTarget> {
new PortfolioTarget(Symbols.SPY, 0)
};
// Create target from an empty insights array
var actualTargets = _algorithm.PortfolioConstruction.CreateTargets(_algorithm, new Insight[0]);
AssertTargets(expectedTargets, actualTargets);
}
public void PythonVersionWarmsUpProperly()
{
using (Py.GIL())
{
SetUpHistoryProvider();
Algorithm.SetStartDate(2013, 10, 08);
Algorithm.SetUniverseSelection(new ManualUniverseSelectionModel());
// Create and set alpha model
dynamic model = Py.Import("EmaCrossAlphaModel").GetAttr("EmaCrossAlphaModel");
var instance = model();
Algorithm.SetAlpha(instance);
var changes = SecurityChangesTests.CreateNonInternal(AddedSecurities, RemovedSecurities);
Algorithm.OnFrameworkSecuritiesChanged(changes);
// Get the dictionary of ema cross indicators
var symbolData = instance.symbolDataBySymbol;
// Check the dictionary is not empty
Assert.NotZero(symbolData.Length());
// Check all Ema Cross indicators from the alpha are ready and have at least
// one datapoint
foreach (var item in symbolData)
{
var fast = symbolData[item].Fast;
var slow = symbolData[item].Slow;
Assert.IsTrue(fast.IsReady.IsTrue());
Assert.NotZero(((PyObject)fast.Samples).GetAndDispose <int>());
Assert.IsTrue(slow.IsReady.IsTrue());
Assert.NotZero(((PyObject)slow.Samples).GetAndDispose <int>());
}
ZipCacheProvider.DisposeSafely();
}
}
public void DuplicateKeyPortfolioConstructionModelDoesNotThrow()
{
var algorithm = new QCAlgorithm();
var timezone = algorithm.TimeZone;
algorithm.SetDateTime(new DateTime(2018, 8, 7).ConvertToUtc(timezone));
algorithm.SetPortfolioConstruction(new DuplicateKeyPortfolioConstructionModel());
var symbol = Symbols.SPY;
var security = new Security(
SecurityExchangeHours.AlwaysOpen(timezone),
new SubscriptionDataConfig(
typeof(TradeBar),
symbol,
Resolution.Daily,
timezone,
timezone,
true,
false,
false
),
new Cash(Currencies.USD, 0, 1),
SymbolProperties.GetDefault(Currencies.USD),
ErrorCurrencyConverter.Instance,
RegisteredSecurityDataTypesProvider.Null,
new SecurityCache()
);
security.SetMarketPrice(new Tick(algorithm.Time, symbol, 1m, 1m));
algorithm.Securities.Add(symbol, security);
algorithm.PortfolioConstruction.OnSecuritiesChanged(algorithm, SecurityChangesTests.AddedNonInternal(security));
var insights = new[] { Insight.Price(symbol, Time.OneMinute, InsightDirection.Up, .1) };
Assert.DoesNotThrow(() => algorithm.PortfolioConstruction.CreateTargets(algorithm, insights));
}
private IEnumerable <Slice> GetSlices(Symbol symbol, int initialVolume)
{
var subscriptionDataConfig = new SubscriptionDataConfig(typeof(ZipEntryName), symbol, Resolution.Second, TimeZones.Utc, TimeZones.Utc, true, true, false);
var security = new Security(
SecurityExchangeHours.AlwaysOpen(TimeZones.Utc),
subscriptionDataConfig,
new Cash(Currencies.USD, 0, 1m),
SymbolProperties.GetDefault(Currencies.USD),
ErrorCurrencyConverter.Instance,
RegisteredSecurityDataTypesProvider.Null,
new SecurityCache()
);
var refTime = DateTime.UtcNow;
return(Enumerable
.Range(0, 10)
.Select(i =>
{
var time = refTime.AddSeconds(i);
var bid = new Bar(100, 100, 100, 100);
var ask = new Bar(110, 110, 110, 110);
var volume = (i + 1) * initialVolume;
return _timeSliceFactory.Create(
time,
new List <DataFeedPacket>
{
new DataFeedPacket(security, subscriptionDataConfig, new List <BaseData>
{
new QuoteBar(time, symbol, bid, i * 10, ask, (i + 1) * 11),
new TradeBar(time, symbol, 100, 100, 110, 106, volume)
}),
},
SecurityChangesTests.CreateNonInternal(Enumerable.Empty <Security>(), Enumerable.Empty <Security>()),
new Dictionary <Universe, BaseDataCollection>())
.Slice;
}));
}
