Start New Discussion 
Back
Reward Discussion 
Hi QC Community,
I'm getting frustrated & need some help. I have tried cloning many simple algorithms & changing the tickers to accept "BTCUSD" & I cant get a single one of them working without multiple errors one after another.
On another note, I am finding it very difficult to debug errors in QC, running the backtest just throws off huge error scripts but I cant even tell which line the issue might be in. You cant access cryptos in the notebook at the moment so cant use that for testing. Can anyone reccomend a good way for developing, testing & debugging these strategies in python? Should I stick to Jupyter notebooks or try get on Visual Studio?
Thanks
Strategy 1 - Simple Breakout
# QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
# Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import clr
clr.AddReference("System")
clr.AddReference("QuantConnect.Algorithm")
clr.AddReference("QuantConnect.Indicators")
clr.AddReference("QuantConnect.Common")
from System import *
import numpy as np
from QuantConnect import *
from QuantConnect.Algorithm import *
from QuantConnect.Indicators import *
import decimal as d
### <summary>
### In this example we look at the canonical 15/30 day moving average cross. This algorithm
### will go long when the 15 crosses above the 30 and will liquidate when the 15 crosses
### back below the 30.
### </summary>
### <meta name="tag" content="indicators" />
### <meta name="tag" content="indicator classes" />
### <meta name="tag" content="moving average cross" />
### <meta name="tag" content="strategy example" />
class ChannelsAlgorithm(QCAlgorithm):
def Initialize(self):
'''Initialise the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must initialized.'''
self.SetStartDate(2016, 01, 01) #Set Start Date
self.SetEndDate(2017, 10, 19) #Set End Date
self.SetCash(10000) #Set Strategy Cash
# Find more symbols here: http://quantconnect.com/data
self.SetBrokerageModel(BrokerageName.GDAX)
self.AddCrypto("BTCUSD", Resolution.Hour)
# create a 15 day exponential moving average
# self.fast = self.EMA("BTCUSD", 15, Resolution.Daily);
# create a 30 day exponential moving average
# self.slow = self.EMA("BTCUSD", 70, Resolution.Daily);
# Create Channels
self.channel = self.DCH("BTCUSD",20,20,Resolution.Daily)
self.previous = None
def OnData(self, data):
'''OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here.'''
# a couple things to notice in this method:
# 1. We never need to 'update' our indicators with the data, the engine takes care of this for us
# 2. We can use indicators directly in math expressions
# 3. We can easily plot many indicators at the same time
# wait for our slow ema to fully initialize
# if not self.slow.IsReady:
# return
# only once per day
if self.previous is not None and self.previous.date() == self.Time.date():
return
# define a small tolerance on our checks to avoid bouncing
tolerance = 0.00015;
holdings = self.Portfolio["BTCUSD"].Quantity
# we only want to go long if we're currently short or flat
if holdings <= 0:
# if the fast is greater than the slow, we'll go long
if self.Securities["BTCUSD"].Price > self.channel.UpperBand:
self.Log("BUY >> {0}".format(self.Securities["BTCUSD"].Price))
self.SetHoldings("BTCUSD", 1.0)
# we only want to liquidate if we're currently long
# if the fast is less than the slow we'll liquidate our long
if holdings > 0 and self.Securities["BTCUSD"].Price < self.channel.LowerBand:
self.Log("SELL >> {0}".format(self.Securities["BTCUSD"].Price))
self.Liquidate("BTCUSD")
self.previous = self.TimeStrategy 2:
from datetime import datetime
import clr
clr.AddReference("System")
clr.AddReference("QuantConnect.Algorithm")
clr.AddReference("QuantConnect.Indicators")
clr.AddReference("QuantConnect.Common")
from System import *
import numpy as np
from QuantConnect import *
from QuantConnect.Algorithm import *
from QuantConnect.Indicators import *
import decimal as d
from datetime import timedelta
class DualThrustAlgorithm(QCAlgorithm):
def Initialize(self):
'''Initialise the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must initialized.'''
self.SetStartDate(2017,01,01)
self.SetEndDate(2017,8,30)
self.SetCash(100000)
equityt = self.AddSecurity(SecurityType.Equity, "SPY", Resolution.Hour)
# equity = self.AddSecurity(SecurityType.Crypto, "BTCUSD", Resolution.Hour)
equity = self.AddCrypto("BTCUSD", Resolution.Daily)
self.syls = equity.Symbol
# schedule an event to fire every trading day for a security
# the time rule here tells it to fire when market open
# self.syl = equity.Symbol
self.syl = "BTCUSD"
# self.Schedule.On(self.DateRules.EveryDay(self.syl),self.TimeRules.AfterMarketOpen(self.syl,5),Action(self.SetSignal))
self.Schedule.On(self.DateRules.EveryDay(), self.TimeRules.Every(timedelta(minutes=10)),Action(self.SetSignal))
self.selltrig = None
self.buytrig = None
self.currentopen = None
def SetSignal(self):
history = self.History("BTCUSD", 4, Resolution.Daily)
k1 = 0.5
k2 = 0.5
self.high = []
self.low = []
self.close = []
for slice in history:
bar = slice[self.syl]
self.high.append(bar.High)
self.low.append(bar.Low)
self.close.append(bar.Close)
# Pull the open price on each trading day
self.currentopen = self.Portfolio[self.syl].Price
HH, HC, LC, LL = max(self.high), max(self.close), min(self.close), min(self.low)
if HH - LC >= HC - LL:
signalrange = HH - LC
else:
signalrange = HC - LL
self.selltrig = self.currentopen - decimal.Decimal(k1) * signalrange
self.buytrig = self.currentopen + decimal.Decimal(k2) * signalrange
def OnData(self,data):
'''OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here.'''
holdings = self.Portfolio[self.syl].Quantity
if self.Portfolio[self.syl].Price >= self.selltrig:
if holdings >= 0:
self.SetHoldings(self.syl, 0.8)
else:
self.Liquidate(self.syl)
self.SetHoldings(self.syl, 0.8)
elif self.Portfolio[self.syl].Price < self.selltrig:
if holdings >= 0:
self.Liquidate(self.syl)
self.SetHoldings(self.syl, -0.8)
else:
self.SetHoldings(self.syl, -0.8)
self.Log("open: "+ str(self.currentopen)+" buy: "+str(self.buytrig)+" sell: "+str(self.selltrig))
10
