def get_symbol_data(symbol, start_date, end_date):
store = alpaca_backtrader_api.AlpacaStore(
key_id=os.environ["alpaca_paper"],
secret_key=os.environ["alpaca_secret_paper"],
paper=True,
usePolygon=False)
DataFactory = store.getdata # or use alpaca_backtrader_api.AlpacaData
data0 = DataFactory(dataname=symbol,
historical=True,
fromdate=start_date,
todate=end_date,
timeframe=bt.TimeFrame.Days)
return data0
def run(ALPACA_API_KEY, ALPACA_SECRET_KEY, ALPACA_PAPER, symbols):
cerebro = bt.Cerebro()
cerebro.addstrategy(SmaCross1)
store = alpaca_backtrader_api.AlpacaStore(key_id=ALPACA_API_KEY,
secret_key=ALPACA_SECRET_KEY,
paper=ALPACA_PAPER)
DataFactory = store.getdata # or use alpaca_backtrader_api.AlpacaData
for s in symbols:
data = DataFactory(dataname=s,
historical=True,
fromdate=datetime(2020, 4, 15),
timeframe=bt.TimeFrame.Minutes)
cerebro.adddata(data)
if not ALPACA_PAPER:
# backtrader broker set initial simulated cash
cerebro.broker.setcash(100000.0)
print('Starting Portfolio Value: {}'.format(cerebro.broker.getvalue()))
cerebro.run()
print('Final Portfolio Value: {}'.format(cerebro.broker.getvalue()))
cerebro.plot()
def runstrategy():
args = parse_args()
# Create a cerebro
cerebro = bt.Cerebro()
storekwargs = dict(
key_id=args.keyid,
secret_key=args.secretkey,
paper=not args.live,
)
store = alpaca_backtrader_api.AlpacaStore(**storekwargs)
broker = store.getbroker() # AlpacaBroker
cerebro.setbroker(broker)
timeframe = bt.TimeFrame.TFrame(args.timeframe)
# Manage data1 parameters
tf1 = args.timeframe1
tf1 = bt.TimeFrame.TFrame(tf1) if tf1 is not None else timeframe
cp1 = args.compression1
cp1 = cp1 if cp1 is not None else args.compression
if args.resample or args.replay:
datatf = datatf1 = bt.TimeFrame.Ticks
datacomp = datacomp1 = 1
else:
datatf = timeframe
datacomp = args.compression
datatf1 = tf1
datacomp1 = cp1
fromdate = None
if args.fromdate:
dtformat = '%Y-%m-%d' + ('T%H:%M:%S' * ('T' in args.fromdate))
fromdate = datetime.datetime.strptime(args.fromdate, dtformat)
DataFactory = store.getdata # AlpacaData
datakwargs = dict(timeframe=datatf,
compression=datacomp,
qcheck=args.qcheck,
historical=args.historical,
fromdate=fromdate,
bidask=args.bidask,
useask=args.useask,
backfill_start=not args.no_backfill_start,
backfill=not args.no_backfill,
tz=args.timezone)
# if args.no_store and not args.broker: # neither store nor broker
# datakwargs.update(storekwargs) # pass the store args over the data
data0 = DataFactory(dataname=args.data0, **datakwargs)
data1 = None
if args.data1 is not None:
if args.data1 != args.data0:
datakwargs['timeframe'] = datatf1
datakwargs['compression'] = datacomp1
data1 = DataFactory(dataname=args.data1, **datakwargs)
else:
data1 = data0
rekwargs = dict(
timeframe=timeframe,
compression=args.compression,
bar2edge=not args.no_bar2edge,
adjbartime=not args.no_adjbartime,
rightedge=not args.no_rightedge,
takelate=not args.no_takelate,
)
if args.replay:
cerebro.replaydata(data0, **rekwargs)
if data1 is not None:
rekwargs['timeframe'] = tf1
rekwargs['compression'] = cp1
cerebro.replaydata(data1, **rekwargs)
elif args.resample:
cerebro.resampledata(data0, **rekwargs)
if data1 is not None:
rekwargs['timeframe'] = tf1
rekwargs['compression'] = cp1
cerebro.resampledata(data1, **rekwargs)
else:
cerebro.adddata(data0)
if data1 is not None:
cerebro.adddata(data1)
if args.valid is None:
valid = None
else:
valid = datetime.timedelta(seconds=args.valid)
# Add the strategy
cerebro.addstrategy(TestStrategy,
smaperiod=args.smaperiod,
trade=args.trade,
exectype=bt.Order.ExecType(args.exectype),
stake=args.stake,
stopafter=args.stopafter,
valid=valid,
cancel=args.cancel,
donotcounter=args.donotcounter,
sell=args.sell,
usebracket=args.usebracket)
# Live data ... avoid long data accumulation by switching to "exactbars"
cerebro.run(exactbars=args.exactbars)
if args.exactbars < 1: # plotting is possible
if args.plot:
pkwargs = dict(style='line')
if args.plot is not True: # evals to True but is not True
npkwargs = eval('dict(' + args.plot + ')') # args were passed
pkwargs.update(npkwargs)
cerebro.plot(**pkwargs)
from lib import alpaca
credentials = alpaca.load_paper_credentials()
class SmaCross(bt.SignalStrategy):
def __init__(self):
sma1, sma2 = bt.ind.SMA(period=10), bt.ind.SMA(period=30)
crossover = bt.ind.CrossOver(sma1, sma2)
self.signal_add(bt.SIGNAL_LONG, crossover)
cerebro = bt.Cerebro()
cerebro.addstrategy(SmaCross)
store = alpaca_backtrader_api.AlpacaStore(key_id=credentials['key_id'],
secret_key=credentials['secret_key'],
paper=True)
cerebro.broker.setcash(100000)
cerebro.broker.setcommission(commission=0.0)
cerebro.addsizer(bt.sizers.PercentSizer, percents=20)
DataFactory = store.getdata
data0 = DataFactory(dataname='AAPL', timeframe=bt.TimeFrame.TFrame("Days"))
cerebro.adddata(data0)
cerebro.run(exactbars=1)
print('Final Portfolio Value: %.2f' % cerebro.broker.getvalue())
cerebro.plot()
if not self.positionsbyname["AAPL"].size:
if self.crossover > 0 or self.crossup > 0:
self.buy(data=data0, size=5) # enter long
# in the market & cross to the downside
if self.positionsbyname["AAPL"].size:
if self.crossover <= 0 or self.crossdown < 0:
self.close(data=data0) # close long position
if __name__ == '__main__':
cerebro = bt.Cerebro()
cerebro.addstrategy(SmaCross1)
store = alpaca_backtrader_api.AlpacaStore(key_id=ALPACA_API_KEY,
secret_key=ALPACA_SECRET_KEY,
paper=True,
usePolygon=False)
DataFactory = store.getdata # or use alpaca_backtrader_api.AlpacaData
if ALPACA_PAPER:
data0 = DataFactory(dataname='AAPL',
historical=False,
timeframe=bt.TimeFrame.Days)
# or just alpaca_backtrader_api.AlpacaBroker()
broker = store.getbroker()
cerebro.setbroker(broker)
else:
data0 = DataFactory(dataname='AAPL',
historical=True,
fromdate=datetime(2015, 1, 1),
timeframe=bt.TimeFrame.Days)
remove_from_backtest(symbol)
starting_portfolio_value = 100000
symbols_list = get_symbols()[0]
clear_watchlist(symbols_list)
number_of_stocks = len(symbols_list)
portfolio_split = starting_portfolio_value / number_of_stocks
for symbol in symbols_list:
ALPACA_PAPER = True
cerebro = bt.Cerebro()
cerebro.addstrategy(TestStrategy)
cerebro.broker.setcash(portfolio_split)
store = alpaca_backtrader_api.AlpacaStore(key_id=API_KEY,
secret_key=SECRET_KEY,
paper=ALPACA_PAPER)
if not ALPACA_PAPER:
broker = store.getbroker()
cerebro.setbroker(broker)
DataFactory = store.getdata
data0 = DataFactory(dataname=symbol,
historical=True,
fromdate=datetime(2019, 11, 13),
timeframe=bt.TimeFrame.TFrame("Days"))
cerebro.adddata(data0)
# Make the data into 5 min bars
# cerebro.resampledata(data0, timeframe=bt.TimeFrame.Minutes, compression=5)
stock_amount_before = cerebro.broker.getvalue()
@author: Mathias Luik
"""
import backtrader as bt
import alpaca_backtrader_api
class SmaCross(bt.SignalStrategy):
def __init__(self):
sma1, sma2 = bt.ind.SMA(period=10), bt.ind.SMA(period=30)
crossover = bt.ind.CrossOver(sma1, sma2)
self.signal_add(bt.SIGNAL_LONG, crossover)
cerebro = bt.Cerebro()
cerebro.addstrategy(SmaCross)
store = alpaca_backtrader_api.AlpacaStore(
key_id='PK9UJEC1G4Z0BVBQ6J77',
secret_key='D2Ne2/8dWZ6HnZ9YyI8bD1geLVUuU5pRTe5TSpJu',
paper=True
)
broker = store.getbroker() # or just alpaca_backtrader_api.AlpacaBroker()
cerebro.setbroker(broker)
DataFactory = store.getdata # or use alpaca_backtrader_api.AlpacaData
data0 = DataFactory(dataname='AAPL', timeframe=bt.TimeFrame.TFrame("Days")) # Supported timeframes: "Days"/"Minutes"
cerebro.adddata(data0)
#cerebro.run(exactbars=1)
#cerebro.plot()
self.buy(data=data0, size=5) # enter long
# in the market & cross to the downside
if self.positionsbyname[symbol].size and self.crossover0 <= 0:
self.close(data=data0) # close long position
if __name__ == '__main__':
import logging
logging.basicConfig(format='%(asctime)s %(message)s', level=logging.INFO)
cerebro = bt.Cerebro()
cerebro.addstrategy(SmaCross1)
store = alpaca_backtrader_api.AlpacaStore(key_id=ALPACA_API_KEY,
secret_key=ALPACA_SECRET_KEY,
paper=IS_LIVE,
usePolygon=USE_POLYGON)
DataFactory = store.getdata # or use alpaca_backtrader_api.AlpacaData
if IS_BACKTEST:
data0 = DataFactory(dataname=symbol,
historical=True,
fromdate=datetime(2020, 7, 1),
todate=datetime(2020, 7, 11),
timeframe=bt.TimeFrame.Days)
else:
data0 = DataFactory(
dataname=symbol,
historical=False,
timeframe=bt.TimeFrame.Days,
backfill_start=True,
def setup_cerebro(IS_BACKTEST):
#=============Setup Cerebro
cerebro = bt.Cerebro(stdstats=False, tradehistory=True)
# risk and tracking
cerebro.addobserver(bt.observers.Broker)
cerebro.addobserver(bt.observers.Trades)
cerebro.addobserver(bt.observers.DrawDown)
# strategy
cerebro.addstrategy(StrategyStoploss)
# Add sizer
cerebro.addsizer(custom_Sizer)
# data store
store = alpaca_backtrader_api.AlpacaStore(paper=not IS_LIVE,
usePolygon=False)
#===========configuring broker
if IS_BACKTEST:
cerebro.broker.set_slippage_perc(SLIPPAGE,
slip_open=True,
slip_limit=True,
slip_match=True,
slip_out=False)
cerebro.broker.set_coc(CHEAT_ON_CLOSE)
cerebro.broker.setcash(BACKTEST_CASH)
cerebro.broker.set_shortcash(SHORT_CASH)
else:
broker = store.getbroker()
cerebro.setbroker(broker)
#===========configuring data
DataFactory = store.getdata # or use alpaca_backtrader_api.AlpacaData
# in backtest, data is minute-bar data
# in live, tickdata is fed via websocket! next() is called by tick, so data need to be resampled to higher resolution!
D = {}
for SYMB in SYMBOLS:
if IS_BACKTEST:
D[SYMB] = DataFactory(dataname=SYMB,
historical=True,
fromdate=FROMDATE,
todate=TODATE,
timeframe=TIMEFRAME,
compression=COMPRESSION,
qcheck=0.00)
else:
fromdate = pendulum.now('US/Eastern') - timedelta(minutes=70)
D[SYMB] = DataFactory(dataname=SYMB,
historical=False,
fromdate=fromdate,
timeframe=bt.TimeFrame.Ticks,
compression=COMPRESSION,
backfill_start=True,
backfill=True,
qcheck=0.5)
#cerebro.adddata(D[SYMB],name=SYMB) # tickdata in live mode
cerebro.resampledata(D[SYMB],
name=SYMB,
timeframe=TIMEFRAME,
compression=COMPRESSION) # bardata in live mode
# analyzers
cerebro.addanalyzer(bt.analyzers.TradeAnalyzer, _name='trades')
cerebro.broker.BACKTEST = []
return cerebro
class SmaCross(bt.SignalStrategy):
def __init__(self):
sma1, sma2 = bt.ind.SMA(period=10), bt.ind.SMA(period=30)
crossover = bt.ind.CrossOver(sma1, sma2)
self.signal_add(bt.SIGNAL_LONG, crossover)
cerebro = bt.Cerebro()
cerebro.addstrategy(SmaCross)
store = alpaca_backtrader_api.AlpacaStore(
#key_id=ALPACA_API_KEY,
#secret_key=ALPACA_SECRET_KEY,
#paper=ALPACA_PAPER
#, base_url='https://data.alpaca.markets/v1'
key_id=ALPACA_API_KEY,
secret_key=ALPACA_SECRET_KEY,
paper=ALPACA_PAPER)
if not ALPACA_PAPER:
broker = store.getbroker() # or just alpaca_backtrader_api.AlpacaBroker()
cerebro.setbroker(broker)
DataFactory = store.getdata # or use alpaca_backtrader_api.AlpacaData
data0 = DataFactory(dataname='AAPL',
historical=True,
fromdate=datetime(2019, 1, 1),
timeframe=bt.TimeFrame.Days)
print(data0)
cerebro.adddata(data0)
todate=pd.Timestamp(enddate),
timeframe=bt.TimeFrame.TFrame("Days"))
cerebro.adddata(data0)
cerebro.run()
cerebro.plot()
if (cerebro.broker.getvalue() != cash):
endvals.append(cerebro.broker.getvalue())
print(tick, 'final value: %.2f' % cerebro.broker.getvalue())
print(sum(endvals) / float(len(endvals)))
cred = json.load(open("credentials.json"))
api_key = cred["key"]
api_secret = cred["secret"]
alpaca = aba.AlpacaStore(key_id=api_key, secret_key=api_secret, paper=True)
data = alpaca.getdata
data0 = data(dataname='JPM',
historical=True,
fromdate=datetime(2018, 8, 1),
timeframe=bt.TimeFrame.Days)
testOnMarket(datetime(2019, 8, 1), datetime.today(), Strategy, 500, 15,
['AAPL', 'JPM', 'AMD', 'SNAP', 'CGC', 'TWTR', 'GPRO', 'AMRN'],
data)
tickers = ['SPY']
#tickers = ['FSLY', 'PINS', 'TWLO', 'NVDA', 'BYND', 'AYX', 'SHOP', 'MDB', 'ESTC', 'TDOC', 'PTON', 'TSLA', 'ROKU', 'CRWD', 'DDOG']
timeframes = {
'1D':1,
}
def process_bar(bar):
# process bar
print(bar)
store = alpaca.AlpacaStore(
#key_id=LIVE_KEY,
#secret_key=LIVE_SECRET_KEY,
key_id=ALPACA_API_KEY,
secret_key=ALPACA_SECRET_KEY,
paper=ALPACA_PAPER
)
api = REST(ALPACA_API_KEY, ALPACA_SECRET_KEY, api_version="v2")
bars = api.get_bars_iter("AAPL", TimeFrame.Minute, "2021-02-08", "2021-02-08", limit=120, adjustment="raw")
for i in bars:
print(i.c)
if not ALPACA_PAPER:
ALPACA_SECRET_KEY = 'D2Ne2/8dWZ6HnZ9YyI8bD1geLVUuU5pRTe5TSpJu'
class SmaCross(bt.SignalStrategy):
def __init__(self):
sma1, sma2 = bt.ind.SMA(period=10), bt.ind.SMA(period=30)
crossover = bt.ind.CrossOver(sma1, sma2)
self.signal_add(bt.SIGNAL_LONG, crossover)
is_live = False
cerebro = bt.Cerebro()
cerebro.addstrategy(SmaCross)
store = alpaca_backtrader_api.AlpacaStore(ALPACA_API_KEY_ID, ALPACA_SECRET_KEY)
if is_live:
broker = store.getbroker() # or just alpaca_backtrader_api.AlpacaBroker()
cerebro.setbroker(broker)
else:
cerebro.broker.setcash(100000)
cerebro.broker.setcommission(commission=0.0)
cerebro.addsizer(bt.sizers.PercentSizer, percents=20)
DataFactory = store.getdata # or use alpaca_backtrader_api.AlpacaData
if is_live:
data0 = DataFactory(
dataname='AAPL',
timeframe=bt.TimeFrame.TFrame("Minutes"),
)
def run(args=None):
# Create a cerebro entity
cerebro = bt.Cerebro()
# parse args
args = parse_args(args)
# Definetrade option
"""
You have 3 options:
- backtest (IS_BACKTEST=True, IS_LIVE=False)
- paper trade (IS_BACKTEST=False, IS_LIVE=False)
- live trade (IS_BACKTEST=False, IS_LIVE=True)
"""
broker = args.broker
IS_BACKTEST = args.isbacktest
IS_LIVE = args.islive
if broker == 'alpaca':
symbol = "SPY"
elif broker == 'ib':
symbol = "SPY-STK-SMART-USD"
# Add a strategy
cerebro.addstrategy(ExuberStrategy)
# Data API store
if broker == 'alpaca':
store = alpaca_backtrader_api.AlpacaStore(
key_id=ALPACA_API_KEY,
secret_key=ALPACA_SECRET_KEY,
paper=IS_LIVE,
usePolygon=USE_POLYGON
)
DataFactory = store.getdata # or use alpaca_backtrader_api.AlpacaData
elif broker == 'ib':
# IB store
store=bt.stores.IBStore(host="127.0.0.1", port=7496, clientId=1)
# Data feed args
from_date = args.fromdate
from_date = datetime.datetime.strptime(from_date, '%Y-%m-%d')
timeframe = bt.TimeFrame.TFrame(args.timeframedata)
compression = args.compression
# Data feed
if IS_BACKTEST:
stockkwargs = dict(
timeframe=bt.TimeFrame.Minutes,
historical=True,
fromdate=from_date,
#todate=datetime.datetime(2020, 10, 10),
compression=1
)
if broker == 'alpaca':
data0 = DataFactory(dataname=symbol, **stockkwargs)
elif broker == 'ib':
data0 = store.getdata(dataname=symbol, **stockkwargs)
cerebro.resampledata(data0, timeframe=bt.TimeFrame.Minutes, compression=60*4)
else:
stockkwargs = dict(
timeframe=bt.TimeFrame.Seconds,
historical=False, # only historical download
qcheck=2.0, # timeout in seconds (float) to check for events
# fromdate=from_date, # get data from..
# todate=datetime.datetime(2020, 9, 22), # get data from..
# latethrough=False, # let late samples through
# tradename=None # use a different asset as order target
)
data0 = store.getdata(dataname=symbol, **stockkwargs)
cerebro.resampledata(data0, timeframe=timeframe, compression=compression)
# or just alpaca_backtrader_api.AlpacaBroker()
if IS_LIVE:
broker = store.getbroker()
cerebro.setbroker(broker)
# Add dat to cerebro
# cerebro.adddata(data0)
# set cash if backtest
if IS_BACKTEST:
# backtrader broker set initial simulated cash
cerebro.broker.setcash(100000.0)
# Set sizer
cerebro.addsizer(bt.sizers.AllInSizer)
# cerebro.broker.set_checksubmit(checksubmit=False)
# Set the commission
# cerebro.broker.setcommission(commission=0.0)
# check returns and banchmarks
# if args.timereturn:
# cerebro.addobserver(bt.observers.TimeReturn,
# timeframe=TIMEFRAMES[args.timeframe])
# else:
# benchdata = data0
# if args.benchdata1:
# data1 = DataFactory(dataname='SPY', historical=True,
# fromdate=from_date,
# timeframe=bt.TimeFrame.Minutes, compression=60)
# cerebro.adddata(data1, name='Data1')
# benchdata = data1
# cerebro.addobserver(bt.observers.Benchmark,
# data=benchdata,
# timeframe=TIMEFRAMES[args.timeframe])
# Run over everything
cerebro.run(maxcpus=2)
# Plot
cerebro.plot()
def run(args=None):
# Create a cerebro entity
cerebro = bt.Cerebro()
# parse args
args = parse_args(args)
# Definetrade option
"""
You have 3 options:
- backtest (IS_BACKTEST=True, IS_LIVE=False)
- paper trade (IS_BACKTEST=False, IS_LIVE=False)
- live trade (IS_BACKTEST=False, IS_LIVE=True)
"""
broker = args.broker
IS_BACKTEST = args.isbacktest
IS_LIVE = args.islive
# symbols
symbols = ["AAPL", "BA", "BBBY", "NVDA"]
if broker == 'ib':
symbols = [s + "-STK-SMART-USD" for s in symbols]
# Add a strategy
cerebro.addstrategy(ExuberStrategy)
# Data API store
if broker == 'alpaca':
store = alpaca_backtrader_api.AlpacaStore(
key_id=ALPACA_API_KEY,
secret_key=ALPACA_SECRET_KEY,
paper=IS_LIVE,
usePolygon=USE_POLYGON
)
DataFactory = store.getdata # or use alpaca_backtrader_api.AlpacaData
elif broker == 'ib':
# IB store
store=bt.stores.IBStore(host="127.0.0.1", port=7496, clientId=1)
# Data feed args
from_date = args.fromdate
from_date = datetime.datetime.strptime(from_date, '%Y-%m-%d')
timeframe = bt.TimeFrame.TFrame(args.timeframedata)
compression = args.compression
resample = False
# Data feed
if IS_BACKTEST:
stockkwargs = dict(
timeframe=bt.TimeFrame.Days,
historical=True,
fromdate=from_date,
# todate=datetime.datetime(2020, 10, 10),
compression=1
)
if broker == 'alpaca':
for s in symbols:
print(f'Adding ticker {s} using {timeframe} timeframe.')
data = DataFactory(dataname=s, **stockkwargs)
if resample:
cerebro.resampledata(data,
timeframe=bt.TimeFrame.Minutes,
compression=60*4)
else:
cerebro.adddata(data)
# ZAVRSITI KADA CU KORISTITI IB
elif broker == 'ib':
data0 = store.getdata(dataname=symbols, **stockkwargs)
else:
stockkwargs = dict(
timeframe=bt.TimeFrame.Seconds,
historical=False, # only historical download
qcheck=2.0, # timeout in seconds (float) to check for events
# fromdate=from_date, # get data from..
# todate=datetime.datetime(2020, 9, 22), # get data from..
# latethrough=False, # let late samples through
# tradename=None # use a different asset as order target
)
data0 = store.getdata(dataname=symbols, **stockkwargs)
cerebro.resampledata(data0, timeframe=timeframe, compression=compression)
# or just alpaca_backtrader_api.AlpacaBroker()
if IS_LIVE:
broker = store.getbroker()
cerebro.setbroker(broker)
# Add dat to cerebro
# cerebro.adddata(data0)
# set cash if backtest
if IS_BACKTEST:
# backtrader broker set initial simulated cash
cerebro.broker.setcash(100000.0)
# cerebro.broker.setcommission(commission=0.0)
# sizer
cerebro.addsizer(bt.sizers.PercentSizer) # 1 / len(symbols)
# Run over everything
cerebro.run(maxcpus=2)
# Plot
cerebro.plot()
print(
f"{day}: Hedging:\n**Negative price action: {self.technical_hedge[0]}. Unemployment increasing: {fundamental_hedge}"
)
else:
print(
f"{day}: Not hedging:\n**Negative price action: {self.technical_hedge[0]}. Unemployment increasing: {fundamental_hedge}"
)
cerebro = bt.Cerebro()
cerebro.addstrategy(St)
cerebro.broker.setcash(100000)
cerebro.broker.setcommission(commission=0.0)
store = alpaca.AlpacaStore(key_id=ALPACA_KEY_ID,
secret_key=ALPACA_SECRET_KEY,
paper=ALPACA_PAPER)
if not ALPACA_PAPER:
print(f"LIVE TRADING")
broker = store.getbroker()
cerebro.setbroker(broker)
DataFactory = store.getdata
for ticker in tickers:
print(f'Adding ticker {ticker}.')
d = DataFactory(dataname=ticker,
timeframe=bt.TimeFrame.Days,
fromdate=fromdate,
todate=todate,
def __init__(self):
sma1, sma2 = bt.ind.EMA(period=10), bt.ind.EMA(period=30)
crossover = bt.ind.CrossOver(sma1, sma2)
EMA50 = bt.ind.EMA(period=50)
EMA200 = bt.ind.EMA(period=50)
RSI14 = bt.ind.RSI_SMA(self.data.close, period=14)
self.signal_add(bt.SIGNAL_LONG, (self.data.close - EMA50) < 0)
self.signal_add(bt.SIGNAL_LONGEXIT_ANY, RSI14 > 70)
cerebro = bt.Cerebro()
cerebro.addstrategy(SmaCross)
store = alpaca_backtrader_api.AlpacaStore(key_id=API_KEY,
secret_key=API_SECRET,
paper=APCA_API_BASE_URL)
cerebro.broker.setcash(100000)
cerebro.broker.setcommission(commission=0.0)
cerebro.addsizer(bt.sizers.PercentSizer, percents=99)
DataFactory = store.getdata # or use alpaca_backtrader_api.AlpacaData
data0 = DataFactory(dataname='FISV',
timeframe=bt.TimeFrame.Days,
fromdate=pd.Timestamp('2018-1-1'),
todate=pd.Timestamp('2019-12-15'),
historical=True)
cerebro.adddata(data0)
cerebro.run()
import backtrader as bt
import alpaca_backtrader_api
class SmaCross(bt.SignalStrategy):
def __init__(self):
sma1, sma2 = bt.ind.SMA(period=10), bt.ind.SMA(period=30)
crossover = bt.ind.CrossOver(sma1, sma2)
self.signal_add(bt.SIGNAL_LONG, crossover)
cerebro = bt.Cerebro()
cerebro.addstrategy(SmaCross)
store = alpaca_backtrader_api.AlpacaStore(
key_id='PK0JQXH59LXYYEUB6J91',
secret_key='Wg8H5lozfpE9JzZJw/BjuESek4psKZ34DwKdW4Io',
paper=True)
broker = store.getbroker() # or just alpaca_backtrader_api.AlpacaBroker()
cerebro.setbroker(broker)
DataFactory = store.getdata # or use alpaca_backtrader_api.AlpacaData
data0 = DataFactory(dataname='AAPL', timeframe=bt.TimeFrame.TFrame(
"Days")) # Supported timeframes: "Days"/"Minutes"
cerebro.adddata(data0)
cerebro.run(exactbars=1)
cerebro.plot()
"""
import alpaca_trade_api as tradeapi
def next(self):
if not self.live_bars:
return
print(datetime.utcnow())
if __name__ == '__main__':
import logging
logging.basicConfig(format='%(asctime)s %(message)s', level=logging.INFO)
cerebro = bt.Cerebro()
cerebro.addstrategy(Resample)
store = alpaca_backtrader_api.AlpacaStore(
key_id=ALPACA_API_KEY,
secret_key=ALPACA_SECRET_KEY,
paper=not IS_LIVE,
)
DataFactory = store.getdata
data0 = DataFactory(dataname=symbol,
historical=False,
timeframe=bt.TimeFrame.Minutes,
qcheck=10.0,
backfill_start=False,
data_feed='iex')
broker = store.getbroker()
cerebro.setbroker(broker)
cerebro.resampledata(data0, compression=2, timeframe=bt.TimeFrame.Minutes)
cerebro.run()
import backtrader as bt
import alpaca_backtrader_api
class SmaCross(bt.SignalStrategy):
def __init__(self):
sma1, sma2 = bt.ind.SMA(period=10), bt.ind.SMA(period=30)
crossover = bt.ind.CrossOver(sma1, sma2)
self.signal_add(bt.SIGNAL_LONG, crossover)
cerebro = bt.Cerebro()
cerebro.addstrategy(SmaCross)
store = alpaca_backtrader_api.AlpacaStore(
key_id='my_paper_key',
secret_key='my_paper_secret_key',
paper=True
)
broker = alpaca_backtrader_api.AlpacaBroker() # store.getbroker() # or just alpaca_backtrader_api.AlpacaBroker()
cerebro.setbroker(broker)
DataFactory = store.getdata # or use alpaca_backtrader_api.AlpacaData
data0 = DataFactory(dataname='AAPL', timeframe=bt.TimeFrame.TFrame("Days")) # Supported timeframes: "Days"/"Minutes"
cerebro.adddata(data0)
cerebro.run(exactbars=1)
cerebro.plot()
