class Controls:
def __init__(self):
self.Securities = {}
self.Portfolio = Portfolio()
self.Transactions = []
self.Schedule = []
def AddToSchedule(self, order):
self.Schedule.append(order)
def MarketOrder(self, ticker, Quantity):
Price = self.Securities[ticker].Price
order = Order(ticker,
Price=Price,
Quantity=Quantity,
Type="MarketOrder")
self.FillOrder(order)
def LimitOrder(self, ticker, Quantity, Price):
order = Order(ticker,
Price=Price,
Quantity=Quantity,
Type="LimitOrder")
self.AddToSchedule(order)
def FillOrder(self, order):
order.Filled = True
self.Transactions.append(order)
self.Portfolio.UpdateHolding(order)
self.Portfolio.UpdatePortfolioValue()
def CancelOrder(self, order):
self.Schedule.remove(order)
def __init__(self, filename, hyperparameters={}):
self.hyperparameters = hyperparameters
self.filename = filename
self.portfolio = Portfolio()
self.portfolio.load(self.filename)
self.downloader = Downloader(cache=False)
self.downloader.download(period='3mo')
def buy(input_string):
"""
+ seperated contracts followed by & and then start date & end date & type
:param input_string:
:return:
"""
inputs = input_string.split('&')
print(inputs)
asset_list = inputs[0].split('+')
start_date = int(inputs[1])
end_date = inputs[2]
asset_types = inputs[3]
myport = Portfolio()
# get assets
for contract in asset_list:
if asset_types == 'options':
mT.get_one_option(contract, myport)
elif asset_types == 'stocks':
mT.get_one_stock(contract, myport)
elif asset_types == 'mixed':
mT.get_one_option(contract, myport)
mT.get_one_stock(contract, myport)
result_dict = myport.buy_hold(
datetime.datetime.fromtimestamp(start_date).date(),
datetime.datetime.fromtimestamp(end_date).date())
return flask.jsonify(result_dict)
def __init__(self):
"""
All the fields in the constructor are required. They are inputs into our real time trading environment.
:return:
"""
# This information is required and defines the data dimensions you will receive our real time
# data provider. An example is provided, feel free to add or remove dimensions. You can find more
# dimensions in the RealTime and Company modules
aDataDimensions = [
Company.SYMBOL,
RealTime.RT_LAST_TRADE,
RealTime.RT_ASK,
RealTime.RT_BID
]
# This information is required. It defines how we configure a trading environment. Please do not remove
# any of these fields. Adding fields will be accessible through self.oAlgoConf.
oAlgorithmConf = {
"name": "Algorithm Name",
"start_bal": 0.0,
"add_balance": 0.0,
"max_positions": 0.0,
"comission": 0.0
}
# Construct the parent
Portfolio.__init__(self, oAlgorithmConf, aDataDimensions)
del aDataDimensions, oAlgorithmConf
def __init__(self,
period='2y',
timedelay=100,
window=100,
timestep=5,
budget=5000,
stockPicks=10,
sl=-0.1,
tp=0.25,
ts=0.2,
ts_threshold=0.05,
avoidDowntrends=True,
sellAllOnCrash=True,
neptune=None,
pick_kwargs={}):
self.neptune = neptune # neptune.ai logging
self.period = period
self.timedelay = timedelay
self.timestep = timestep
self.budget = budget
self.stockPicks = stockPicks
self.sl = sl
self.tp = tp
self.ts = ts
self.ts_threshold = ts_threshold
self.avoidDowntrends = avoidDowntrends
self.sellAllOnCrash = sellAllOnCrash
self.pick_kwargs = pick_kwargs
self.portfolio = Portfolio(cash=budget, sl=self.sl, tp=self.tp)
self.downloader = Downloader()
self.downloader.download(period=self.period)
self.current_index = timedelay
self.is_notebook = self.isNotebook()
def run_portfolio_single(trade_info, parameter, config, print_result):
global print_times
config_local = Configuration.Configuration(config=config)
if not print_result:
config_local.turn_off_log()
trades = signal_to_trades(trade_info, parameter)
portfolio = Portfolio(trades, config_local)
result = portfolio.run(config_local.start_time, config_local.end_time)
print_times += 1
if config_local.detail_report:
if result is None:
print("error")
net_profit = result.get_value('Total Net Profit', config_local.name)
max_dd = result.get_value('Max Drawdown', config_local.name)
hratio = result.get_value('Percent Profitable', config_local.name)
print(
f"{print_times}: finished {parameter}: return({net_profit:.2f}),hratio({hratio*100:.2f}%),maxdd({max_dd:.2f})"
)
if config_local.optimise_target == 1:
result = net_profit
elif config_local.optimise_target == 2:
result = hratio
elif config_local.optimise_target == 3:
result = net_profit / abs(max_dd)
else:
raise Exception("should not be here")
else:
print(f"{print_times}:finished {parameter}: return({result:.2f})")
return result
class StockBroker:
def __init__(self, initialCashDeposit, stockRepository):
self.__portfolio = Portfolio(initialCashDeposit, stockRepository)
self.stockRepository = stockRepository
def MarketBuy(self, stockTickerSymbol, quantity):
self.__portfolio.Buy(stockTickerSymbol, quantity)
def MarketSell(self, stockTickerSymbol, quantity):
self.__portfolio.Sell(stockTickerSymbol, quantity)
# Set order to buy a stock if it hits a certain price.
def LimitBuy(self, stockTickerSymbol, quantity, buyLimit):
return 'Not yet implemented'
# Set order to sell a stock if it hits a certain price.
def LimitSell(self, stockTickerSymbol, quantity, sellLimit):
return 'Not yet implemented'
# Set order to buy a stock at market price, then sell if it hits the
# sellPrice
def StopLoss(self, stockTickerSymbol, quantity, sellPrice):
return 'Not yet implemented'
def GetPortfolio(self):
return self.__portfolio
def _BinarySolveIndividualSell(self, input_args):
"""Check if an individual sale of stock is an improvement on the current regime."""
(best, trade_amount, best_score, sell) = input_args
if best[sell] < trade_amount:
return (best, best_score)
curr = np.copy(best)
for buy in xrange(len(best)):
if buy == sell:
continue
curr[sell] -= trade_amount
curr[buy] += trade_amount
portfolio = Portfolio(self._stock_db, percent_allocations=curr)
curr_score = portfolio.getScore(self._required_return)
if curr_score > best_score:
best_score = curr_score
best = np.copy(curr)
curr[sell] += trade_amount
curr[buy] -= trade_amount
return (best, best_score)
def strategy3():
lookback = 100
print("Running Strategy 3.")
scpr = JScraper(browser_type="chrome",
browser_driverpath="./browserdrivers/chromedriver")
p = Portfolio("portfolio_strat3.pf")
myportfolio = p.getPortfolio()
while True:
# try to intelligently buy
for curr in myportfolio:
meds = scpr.retrieveMedians(curr=curr, max=lookback)
if len(meds) < lookback:
continue #Do nothing until
curr_median = meds[0]
deviation_of_median = 0
variance_of_median = 0
mean_of_median = 0
for m in meds:
mean_of_median = mean_of_median + m
mean_of_median = mean_of_median / len(meds)
for m in meds:
variance_of_median = variance_of_median + math.pow(
(m - mean_of_median), 2)
variance_of_median = variance_of_median / len(meds)
deviation_of_median = math.sqrt(variance_of_median)
zscore_of_median = (
curr_median - mean_of_median
) / deviation_of_median #number of std dev's away
print(
str(curr) + ": MOst recent median: " + str(curr_median) +
" mean of median: " + str(mean_of_median) + " z-score: " +
str(zscore_of_median))
MAX_PERCENT_ALLOWANCE = .10
if (zscore_of_median <
-0.75): #Buying when price is in 0-22nd percentile
purchase_amt = MAX_PERCENT_ALLOWANCE * p.getCashpool()
purchase_price = curr_median
shares = purchase_amt / purchase_price
p.purchase(curr, shares)
print("Buying " + str(shares) + " of " + str(curr) + " at " +
str(curr_median) + "(Total price " +
str(shares * purchase_price) + ").")
elif (zscore_of_median > 0.3):
share_ct = p.amount(
curr) #Selling when price is in 62-100th percentile
if not (share_ct == -1 or share_ct <= 0.0):
sell_ct = MAX_PERCENT_ALLOWANCE * share_ct
purchase_price = curr_median
p.sell(curr, sell_ct)
print("Selling " + str(sell_ct) + " of " + str(curr) +
" at " + str(curr_median) + "(Total price " +
str(sell_ct * purchase_price) + ").")
else: #if price isnt significant, do nothing
pass
print(p)
print("Total worth: " + str(p.getWorth()) + ".\n")
time.sleep(TIME_BETWEEN_ITERATIONS) #sec
def test_GetTotalValue_ThreeSharesOfApple(self):
mockStockRepository = BackTestStockRepository()
mockStockRepository.GetCurrentStockPrice = MagicMock(return_value = 200)
startingCash = 1000
portfolio = Portfolio(startingCash, mockStockRepository)
portfolio.heldStocks['AAPL'] = 3
expectedValue = 1600
actualValue = portfolio.GetTotalValue()
self.assertEqual(expectedValue, actualValue)
def run(self, oNewData):
"""
Our trading environment will call this method when new data arrives. There's some setup we need to do
before you start trading
:param oNewData: objects where keys are tickers and values are market data
:return:
"""
Portfolio.update(self, oNewData)
self.trade(oNewData)
class LiveTrade:
"""
LiveTrade is used to interact with the running Falkor program.
It allows the user to add new securities to trade on, viewing
portfolio, current trades, alerting, etc.
Attributes:
portfolio: Portfolio
- portfolio containing all Security's trading
gekko: Gekko
- Gekko instance
Methods:
run(self, interval_secs: int)
- Main method used to run FALKOR
"""
def __init__(self):
"""Initialize LiveTrade"""
self.portfolio = Portfolio()
self.gekko = Gekko(self.portfolio)
# Add ETHBTC as a security
model = CNN()
cnn_strat = CNN_Strategy(model=model,
weights_path='model_weights/cnn_weights',
image_path='strategies/images/')
api_wrapper = BinanceWrapper(
client_id=
'nBjgb83VMNvqq45b3JdWUIsJDalWlXxHI2bvDz9oLdW7KgOLPvJCp30CHnthjfNJ',
client_secret=
'5bBN7s7h37kUvmGIpF9FTAtspBY93WirwhTh39PV7AlKSlUE2S4EEe9b3OZVYIqd')
ethbtc = Security('ETHBTC',
'1m',
shares=0,
api_wrapper=api_wrapper,
strategy=cnn_strat)
self.portfolio.add_security(ethbtc)
def run(self, interval_secs: int):
"""Begin pulling recent candles, generating trading signals, and trading."""
while True:
# trade portfolio
self.gekko.trade_portfolio()
# display portfolio information
self.portfolio.display()
# sleep until next candlestick of data is avaliable
time.sleep(interval_secs)
def test_portfolio_mix():
portfolio = Portfolio(100.0)
funds, position = portfolio.apply_action(Action.CLOSE, 10.0, 0)
assert funds == 100.0
assert position == 0
funds, position = portfolio.apply_action(Action.LONG, 40.0, 0)
assert funds == 20.0
assert position == 2
funds, position = portfolio.apply_action(Action.LONG, 5.0, 0)
assert funds == 0.0
assert position == 6
funds, position = portfolio.apply_action(Action.CLOSE, 10.0, 0)
assert funds == 60.0
assert position == 0
funds, position = portfolio.apply_action(Action.SHORT, 10.0, 0)
assert funds == 120.0
assert position == -6
failed = False
try:
portfolio.apply_action(Action.LONG, 20.0, 0)
except:
failed = True
assert failed
def setStrategy(self, strategy):
self.strategy = strategy
print "BackTest Strategy: %s" % self.strategy.description
self.initializeDataHandler()
self.portfolio = Portfolio(self.capital, self.dataHandler)
self.portfolio.setQueue(self.event)
self.strategy.setQueue(self.event)
def run():
start_time = datetime.datetime.now()
print('=== Begin ========== ' + str(start_time) + ' ========== ')
print()
# Backtest information
title = ['Super Trend Cross Over']
initial_equity = 10000.0
start_date = datetime.datetime(2014, 1, 1)
end_date = datetime.datetime(2017, 1, 1)
markets = ["test_coin_10rows"]
strategies = ["StrategySTC"]
exchange = "Cryptopia"
Interval = "Day_1"
# markets = ["Bitcoin","DaleCoin","Tierion"]
# strategies = ["StrategySTC","StrategySTC","StrategySTC"]
#Create the Market Strategy list for the Portfolio
market_strategies = []
for market, strategy in zip(markets, strategies):
market_strategies.append(
MarketStrategy(market, exchange, interval, strategy, start_date,
end_date))
# Use the MAC Strategy
# events_queue = queue.Queue()
# set up the portfolio
portfolio = Portfolio()
portfolio.addMarketStrategy(market_strategies)
# run the backetest
backtester = BackTester(title, initial_equity, market_strategies,
start_date, end_date)
results = backtester.runBacktest()
# Set up the backtest
# backtest = TradingSession(
# config, strategy, tickers,
# initial_equity, start_date, end_date,
# events_queue, title=title,
# benchmark=tickers[1],
# )
# results = backtest.start_trading(testing=testing)
end_time = datetime.datetime.now()
run_time = end_time - start_time
print()
print('=== End ========== ' + str(end_time) + ' ========== ' +
" run time: " + str(run_time) + ' ========== ')
return portfolio
def test_downsideCorrel(self):
portfolio = Portfolio(self.stock_db,
percent_allocations=[0.5, 0.4, 0.1])
returns = np.array([1.01, 1.02, 1.03, 1.04, 1.05], dtype=np.float64)
portfolio.backtested_returns = returns
portfolio._stock_db.price_change_array = [[1.00, 1.01, 1.02],
[1.01, 1.00, 1.03],
[1.02, 0.99, 1.04],
[1.03, 0.98, 1.05],
[1.04, 0.97, 1.06]]
portfolio.getScore(1.05)
self.assertAlmostEqual(portfolio.downside_correl, 0.04)
def test_GetTotalValue_ThreeSharesOfApple_ThreeSharesOfMicrosoft(self):
# Arrange
mockStockRepository = BackTestStockRepository()
mockStockRepository.GetCurrentStockPrice = MagicMock(return_value = 200)
startingCash = 1000
portfolio = Portfolio(startingCash, mockStockRepository)
portfolio.heldStocks['AAPL'] = 3
portfolio.heldStocks['MSFT'] = 3
expectedValue = 2200
# Act
actualValue = portfolio.GetTotalValue()
# Assert
self.assertEqual(expectedValue, actualValue)
def test_score(self):
portfolio = Portfolio(self.stock_db,
percent_allocations=[0.5, 0.4, 0.1])
returns = np.array([1.01, 1.02, 1.03, 1.04, 1.05], dtype=np.float64)
portfolio.backtested_returns = returns
portfolio._stock_db.price_change_array = [[1.00, 1.01, 1.02],
[1.01, 1.00, 1.03],
[1.02, 0.99, 1.04],
[1.03, 0.98, 1.05],
[1.04, 0.97, 1.06]]
score = portfolio.getScore(1.021)
self.assertAlmostEqual(portfolio.score, -5.80858974126046)
self.assertAlmostEqual(score, -5.80858974126046)
def intraday_trading_with_robinhood(self,
pmgr,
pname,
args={
"frequent": 2,
"call_from_mgr": False
},
misc={
"w": 0.02,
"cancel_count": 15
}):
"""
frequently trading with this algorithm,
your should have over 20000$ in your account for this method otherwise robinhood will keeps you from intraday trading
the frequent parameter is measured in minutes
"""
params = locals()
#print(params)
params.pop('self')
params['method'] = 'one_trade_per_day_with_quandl_and_robinhood'
params['freq'] = args['frequent']
if not self.algo_header(**params):
return
w = misc['w']
p = pmgr.portfolios[pname]
self.raw_data.loc[Portfolio.get_time()] = p.quote_last_price(
*self.scodes)
if len(self.raw_data) < self.period:
return
DDX = ((self.row_data - self.raw_data.shift(1)) /
self.raw_data.shift(1)).iloc[-self.period:]
w_target = self.one_trade(data=DDX, w=w)
w_current = pd.Series(
p.get_weights(*self.scodes)).loc[self.scodes].values
w_diff = w_target - w_current
s_diff = pd.Series(
((w_diff * p.get_market_value()) /
self.data.loc[Portfolio.get_time()].values).astype(int),
index=self.scodes)
p.log_lock.acquire()
p.log.append("{}: decision made : {}".format(Portfolio.get_time(),
str(s_diff)))
p.log_lock.release()
self.market_decision_exe(p, s_diff)
def exampleFronttesting():
logger = Logger()
logger.addTarget('log/fronttestlog.txt')
portfolio = Portfolio(1000)
portfolio.addAsset(Asset('ethereum', 'ETH'))
end_date = datetime.datetime(2019, 2, 15)
timeframe = datetime.timedelta(minutes=5)
apiKey = 'SOME BINANCE API KEY'
privKey = 'SOME BINANCE PRIV KEY'
trader = TestTrader(portfolio, logger, 0)
trader.fronttest(apiKey, privKey, end_date, timeframe)
def test_Buy_CashLessThanPurchasePrice_RemainderCashAfterPurchase(self):
# Arrange
mockStockRepository = BackTestStockRepository()
mockStockRepository.GetCurrentStockPrice = MagicMock(return_value = 300)
startingCash = 1000
portfolio = Portfolio(startingCash, mockStockRepository)
expectedPortfolioValue = 1000
expectedStockHeldQuantity = 3
numberOfStocksToPurchase = 6
# Act
portfolio.Buy('AAPL', numberOfStocksToPurchase)
# Assert
actualValue = portfolio.GetTotalValue()
self.assertEqual(actualValue, expectedPortfolioValue)
self.assertEqual(expectedStockHeldQuantity, portfolio.heldStocks['AAPL'])
def finastro_sim():
# Add stock data
ticker_group = 'FinAstro'
tickers = ['LON:FTSE100']
df_tickers = da.create_df_from_tickers(tickers)
# Add Ephemeris data
df_eph = create_ephemeris_df()
df_eph = df_eph[(df_eph.index > '2001-01-01')
& (df_eph.index < '2019-09-30')]
df = df_eph.join(df_tickers, how='inner')
# Generate long/short tickers i.e. signals
df = Strategy.create_long_short_tickers(tickers, df, ticker_group)
# Run backtest
portfolio = Portfolio(df)
Backtest.run(df, portfolio)
Performance.metrics(portfolio, ticker_group)
# Outputs
pd.options.display.float_format = '{:20,.2f}'.format
portfolio.orders_df.to_csv(cp.files['orders'])
portfolio.trades_df.to_csv(cp.files['trades'])
portfolio.df.to_csv(cp.files['backtest'])
portfolio.metrics_df.to_csv(cp.files['metrics'])
print(portfolio.metrics_df)
Graphs.equity_curve(df=portfolio.df)
def test_SellAllStocks_SellOrderLessThanHeldQuantity(self):
# Arrange
mockStockRepository = BackTestStockRepository()
mockStockRepository.GetCurrentStockPrice = MagicMock(return_value = 300)
startingCash = 1000
portfolio = Portfolio(startingCash, mockStockRepository)
portfolio.heldStocks['AAPL'] = 10
numberOfStocksToSell = 5
expectedStockHeldQuantity = 5
expectedPortfolioValue = 4000
# Act
portfolio.Sell('AAPL', numberOfStocksToSell)
# Assert
actualValue = portfolio.GetTotalValue()
self.assertEqual(expectedPortfolioValue, actualValue)
self.assertEqual(expectedStockHeldQuantity, portfolio.heldStocks['AAPL'])
def hodl():
# initialize our dataframe
sims = pd.DataFrame(index=hist_prices['timestamp'])
coins = hist_prices.columns[1:].tolist()
# convert our dataframe to numpy so we can find the dot product of quantities and prices
df = np.array(hist_prices[coins])
# run 250 simulations
for sim_num in range(250):
# randomly select 5 coins to simulate
random_coins = random.sample(coins, 5)
coin_indices = [coins.index(coin) for coin in random_coins]
df_small = df[:, coin_indices]
# create portfolio class object
myPortfolio = Portfolio(random_coins)
# Combine the coin list with '-' to use as the column name
col = '-'.join(random_coins)
# Multiply quantities we own by hourly prices to get price for each hour
sims[col] = list(np.dot(df_small, myPortfolio.quantities))
sims.to_csv('data/simulations/hodl.csv')
return sims
def mixed_trading_simulator(self,
data=None,
idata=None,
robin_un=None,
robin_pd=None):
if data is None:
data = self.quandl_today_data_generator()['data_p']
if idata is None:
idata = self.rh_intraday_data_generator(robin_un,
robin_pd,
span='day')['data_p']
qdata = (idata - idata.shift(1)) / idata.shift(1)
qdata.iloc[0] = (idata.iloc[0] - data.iloc[-1]) / data.iloc[-1]
idata = (idata - data.iloc[-1]) / data.iloc[-1]
data = ((data - data.shift(1)) / data.shift(1)).dropna()
now = Portfolio.get_time()
ws = [np.zeros(len(self.scodes))]
rs = []
v = []
for i in range(len(idata)):
data.loc[now] = idata.iloc[i]
w = self.one_trade(data)
rs.append(np.dot(ws[-1], qdata.iloc[i]))
ws.append(w)
m = np.array(rs) + 1
for i in range(1, len(m)):
m[i] *= m[i - 1]
return rs, ws, m, v
def exampleBinance():
logger = Logger()
logger.addTarget('log/log.txt', 0)
portfolio = Portfolio()
portfolio.addAsset(Asset('ethereum', 'ETH'))
apiKey = 'insert api key here'
privKey = 'insert private key here'
market = BinanceMarket(apiKey, privKey)
end = datetime.datetime(2019, 1, 25)
tf = datetime.timedelta(minutes=5)
trader = TestTrader(portfolio, logger, 0)
trader.trade(market, end, tf)
def manager_portfolio_update(p, start_date=datetime.date.today()):
tickers = p[0]
number_shares = p[1]
costs = p[2]
old_ports = pull_old_portfolios()
if len(old_ports) == 0:
cash = 10000
else:
last_port = old_ports[-1].uncompile()
cash = last_port.cash + last_port.daily_values[-1]
#replace by querying some database for the current (intra day) price instead of the last closing price for value at which you sold.
df = manager_data_update(tickers)
df = df.dropna(
thresh=len(tickers), axis=0
) #this line restrict historical calculations to data points shared by all equities
all_dates = df.index
assets = []
for i in range(len(tickers)):
symbol = tickers[i]
n_shares = number_shares[i]
in_price = costs[i]
returns = df[symbol]
returns_sp = df['^GSPC']
direction_pos = direction(n_shares)
assets.append(
Position(symbol, returns, direction_pos, in_price, n_shares,
returns_sp))
latest_portfolio = Portfolio(assets, start_date, all_dates, cash)
return latest_portfolio
def getInputData():
"""Get all necessary input data for running a model.
Returns:
current_portfolio {Portfolio}: A Portfolio of current investments.
stock_db {StockDatabase}: A database of all necessary stock info.
"""
# Get current allocations.
current_alloc_dict = DataIO.getCurrentData('data/current_allocations.csv')
# Get tickers and expense ratios.
ticker_list, expense_ratio_dict = DataIO.getTickerList(
'data/tickers_expenses.csv')
# Get raw data.
raw_data = DataIO.getRawData(ticker_list)
# Create all stock objects.
stock_dict = {}
for ticker in raw_data.keys():
stock_dict[ticker] = Stock(raw_data[ticker], ticker,
expense_ratio_dict[ticker])
if not len(stock_dict.keys()):
raise ValueError('No keys found.')
# Create stock database.
stock_db = StockDatabase(stock_dict)
# Create current portfolio.
current_portfolio = Portfolio(stock_db,
percent_allocations_dict=current_alloc_dict)
return current_portfolio, stock_db
def __init__(self):
self.latch = None
self.strategies = []
self.portfolio = Portfolio('portfolio', None)
self.exchange = Exchange()
self.portfolio.IN_fills = self.exchange.OUT_fills
self.stats = None
self.verbose = True
## call on_EOD funcs at end of data file
self.reset_on_EOD = True
self.scoring_function = None
def test_sell_stock(self):
p5 = Portfolio(first_name="James", last_name="Doland")
p5.add_stock("T", 1, 170)
p5.add_stock("SPHD", 2, 270)
p5.sell_stock("SPHD", 1)
self.assertEqual(p5.stock_tick_opt, {"T": 1.0, "SPHD": 1.0})
self.assertEqual(p5.stock_tick_avg, {"T": 170.0, "SPHD": 270.0})
def calculate_monthly_performance(self, filing_date, month, year):
#portfolio = Portfolio(self.members_list, quarter_date)
portfolio = Portfolio(self.members_list, filing_date=filing_date)
previous_month_end = date(year, month, 1) - timedelta(days=1)
current_month_end = (date(year, month, 1) + timedelta(days=32)
).replace(day=1) - timedelta(days=1)
return PortfolioReturn(portfolio.portfolio.copy(), previous_month_end,
current_month_end).get_portfolio_performance()
def get_portfolio(self, session_token):
result = self.db.get_portfolio(session_token)
if not result:
return None
user_id, data = result
fonds = {fond_data["ticker"]: Fond(**fond_data) for fond_data in data}
return Portfolio(user_id, fonds)
def setup_portfolio(self, series_list):
'''
Sets up portfolio containing Equity Trades with Names and series related to list
returns initialised port
'''
#Setup portfolio
trades = [ TradeEquity(series, notional=0,price_series_label=series) for series in series_list]
#Create portfolio
port = Portfolio("portfolio", cashAmt=100)
for td in trades:
port.add_trade(td)
#No more trade types
port.fixed_toggle()
return port
def setStrategy(self,strategy):
self.strategy = strategy
print "BackTest Strategy: %s" % self.strategy.description
self.initializeDataHandler()
self.portfolio = Portfolio(self.capital,self.dataHandler)
self.portfolio.setQueue(self.event)
self.strategy.setQueue(self.event)
def __init__(self, sLimit, sAssumptions, eAssumptions, iAssumptions, aAssumptions, dAssumptions):
# Assumptions
self.screenLimit = sLimit
self.screenAssumptions = sAssumptions
self.evaluateAssumptions = eAssumptions
self.incubateAssumptions = iAssumptions
self.accelerateAssumptions = aAssumptions
self.developAssumptions = dAssumptions
# set up portfolio
self.portfolio = Portfolio(self.screenAssumptions, self.evaluateAssumptions, self.incubateAssumptions, self.accelerateAssumptions, self.developAssumptions)
self.year = 1
# Totals to report to looper
self.totalScreen = 0
self.totalEvaluate = 0
self.totalIncubate = 0
self.totalAccelerate = 0
self.totalDevelop = 0
self.totalSuccess = 0
self.totalBudget = 0
self.peakBudget = 0
self.peakHeadcount = 0
self.finalBudget = 0
# New projects
self.newScreen = 0
self.newEvaluate = 0
self.newIncubate = 0
self.newAccelerate = 0
self.newDevelop = 0
self.newSuccess = 0
# Add screen projects up to the limit
k = 1
while k <= self.screenLimit:
self.portfolio.addScreen()
self.totalScreen = self.totalScreen + 1
self.newScreen = self.newScreen + 1
k = k + 1
# Add T1D as an incubate project
self.portfolio.addIncubate()
self.totalIncubate = self.totalIncubate + 1
self.newIncubate = self.newIncubate + 1
# Record the year's progress for the first year
self.portfolio.addYear(self.year, self.newScreen, self.newEvaluate, self.newIncubate, self.newAccelerate, self.newDevelop, self.newSuccess)
self.totalBudget = self.totalBudget + self.portfolio.getAnnualBudget()
self.peakBudget = self.portfolio.getAnnualBudget()
self.peakHeadcount = self.portfolio.getAnnualHeadcount()
returns = np.array(port_weighted_daily_return["Portfolio Weighted Daily Return"])
m_returns = np.array(benchmark_returns["^GSPC"])
slope, intercept, r_value, p_value, std_err = stats.linregress(returns, m_returns)
return slope
def get_portfolio_treynor_measure(self):
port_treynor_measure = float((ex_port_return - risk_free_rate))/beta
return port_treynor_measure
def get_portfolio_alpha_measure(self):
port_alpha_measure = ex_port_return - (risk_free_rate + beta*(market_portfolio_expected_return - risk_free_rate))
return port_alpha_measure
## Refer to class Portfolio
# create a portfolio consisting of several stocks
portfolio = Portfolio(["GOOGL", "AAPL", "MSFT"], [0.3, 0.4, 0.3])
# let us add a new stock to portfolio with new weights: sum of weights should equal to 1
portfolio.add_stocks("^DJI", [0.2, 0.2, 0.4, 0.2])
# get a list of stocks within the portfolio
stocks = portfolio.get_stocks()
# get a list of weights of the stocks within the portfolio
weights = portfolio.get_weights()
## Refer to class MarketDataProvider to get market data for stocks selected for the portfolio
# define an instance of class MarketDataProvider()
provider = MarketDataProvider()
# retrieve stock prices for the period from yahoo
stock_prices = provider.import_market_data(stocks, "1/1/2015", "7/1/2015")
class Accelerator(object):
def __init__(self, sLimit, sAssumptions, eAssumptions, iAssumptions, aAssumptions, dAssumptions):
# Assumptions
self.screenLimit = sLimit
self.screenAssumptions = sAssumptions
self.evaluateAssumptions = eAssumptions
self.incubateAssumptions = iAssumptions
self.accelerateAssumptions = aAssumptions
self.developAssumptions = dAssumptions
# set up portfolio
self.portfolio = Portfolio(self.screenAssumptions, self.evaluateAssumptions, self.incubateAssumptions, self.accelerateAssumptions, self.developAssumptions)
self.year = 1
# Totals to report to looper
self.totalScreen = 0
self.totalEvaluate = 0
self.totalIncubate = 0
self.totalAccelerate = 0
self.totalDevelop = 0
self.totalSuccess = 0
self.totalBudget = 0
self.peakBudget = 0
self.peakHeadcount = 0
self.finalBudget = 0
# New projects
self.newScreen = 0
self.newEvaluate = 0
self.newIncubate = 0
self.newAccelerate = 0
self.newDevelop = 0
self.newSuccess = 0
# Add screen projects up to the limit
k = 1
while k <= self.screenLimit:
self.portfolio.addScreen()
self.totalScreen = self.totalScreen + 1
self.newScreen = self.newScreen + 1
k = k + 1
# Add T1D as an incubate project
self.portfolio.addIncubate()
self.totalIncubate = self.totalIncubate + 1
self.newIncubate = self.newIncubate + 1
# Record the year's progress for the first year
self.portfolio.addYear(self.year, self.newScreen, self.newEvaluate, self.newIncubate, self.newAccelerate, self.newDevelop, self.newSuccess)
self.totalBudget = self.totalBudget + self.portfolio.getAnnualBudget()
self.peakBudget = self.portfolio.getAnnualBudget()
self.peakHeadcount = self.portfolio.getAnnualHeadcount()
def runAccelerator(self):
# Increase the year
self.year = self.year + 1
# Reset the new project counters
self.newScreen = 0
self.newEvaluate = 0
self.newIncubate = 0
self.newAccelerate = 0
self.newDevelop = 0
# Grow existing projects. Let them succeed or fail
self.portfolio.nextYear()
# Add new screens
if self.year <= 2:
screenAdd = self.screenLimit
else:
screenAdd = self.screenAssumptions[4]
self.newScreen = screenAdd
while screenAdd > 0:
self.portfolio.addScreen()
self.totalScreen = self.totalScreen + 1
screenAdd = screenAdd - 1
# Move successful screens to evaluate
evaluateAdd = self.portfolio.getAnnualScreenSuccesses()
self.newEvaluate = evaluateAdd
while evaluateAdd > 0:
self.portfolio.addEvaluate()
self.totalEvaluate = self.totalEvaluate + 1
evaluateAdd = evaluateAdd - 1
# Move successful evaluate to incubate
incubateAdd = self.portfolio.getAnnualEvaluateSuccesses()
self.newIncubate = incubateAdd
while incubateAdd > 0:
self.portfolio.addIncubate()
self.totalIncubate = self.totalIncubate + 1
incubateAdd = incubateAdd - 1
# Move successful incubate to accelerate
accelerateAdd = self.portfolio.getAnnualIncubateSuccesses()
self.newAccelerate = accelerateAdd
while accelerateAdd > 0:
self.portfolio.addAccelerate()
self.totalAccelerate = self.totalAccelerate + 1
accelerateAdd = accelerateAdd - 1
# Move successful accelerate to develop
developAdd = self.portfolio.getAnnualAccelerateSuccesses()
self.newDevelop = developAdd
while developAdd > 0:
self.portfolio.addDevelop()
self.totalDevelop = self.totalDevelop + 1
developAdd = developAdd - 1
# Find number of successes that year
self.newSuccess = self.portfolio.getAnnualDevelopSuccesses()
self.totalSuccess = self.totalSuccess + self.portfolio.getAnnualDevelopSuccesses()
# Record this year's progress
self.portfolio.addYear(self.year, self.newScreen, self.newEvaluate, self.newIncubate, self.newAccelerate, self.newDevelop, self.newSuccess)
# Add totals
self.totalBudget = self.totalBudget + self.portfolio.getAnnualBudget()
if self.portfolio.getAnnualBudget() > self.peakBudget:
self.peakBudget = self.portfolio.getAnnualBudget()
if self.portfolio.getAnnualHeadcount() > self.peakHeadcount:
self.peakHeadcount = self.portfolio.getAnnualHeadcount()
if self.year == 16:
self.finalBudget = self.portfolio.getAnnualBudget()
def getFinalBudget(self):
return self.finalBudget
def getTotalBudget(self):
return self.totalBudget
def getPeakBudget(self):
return self.peakBudget
def getPeakHeadcount(self):
return self.peakHeadcount
def getTotalSuccess(self):
return self.totalSuccess
def getTotalDevelop(self):
return self.totalDevelop
def getTotalAccelerate(self):
return self.totalAccelerate
def getTotalIncubate(self):
return self.totalIncubate
def getTotalEvaluate(self):
return self.totalEvaluate
def getTotalScreen(self):
return self.totalScreen
def writeModel(self):
if sys.version_info >= (3,0,0):
self.outfile = open('output.csv', 'w', newline='')
self.csvout = csv.writer(self.outfile)
else:
self.outfile = open("output.csv", "wb")
self.csvout = csv.writer(self.outfile)
data = ["Year","Screen","Evaluate","Incubate","Accelerate","Develop","Success","Total Budget","Total Headcount"]
self.csvout.writerow(data)
self.portfolio.printModel(self.csvout, self.outfile)
def __init__(self, balance, log=False, commission=.0002, flat_rate=8):
self.portfolio = Portfolio(balance, commission, flat_rate)
self._log = log
self._today_data = None
self.day = 0
class Strategy(object):
def __init__(self, balance, log=False, commission=.0002, flat_rate=8):
self.portfolio = Portfolio(balance, commission, flat_rate)
self._log = log
self._today_data = None
self.day = 0
def run(self, data_stream):
for i in range(data_stream.shape[1]):
self._today_data = data_stream.iloc[:, i, :]
self.observe_datum(data_stream.iloc[:, i, :])
self.act()
self.day += 1
def observe_datum(self, datum):
raise NotImplementedError
def log(self, string):
if self._log:
print(string)
def liquidate(self):
for ticker in self.portfolio.tickers():
self.sell_max(ticker)
def act(self):
raise NotImplementedError
def price(self, tickers):
return self._today_data['Adj Close'][tickers]
def value(self, correct=True):
datum = self._today_data
return self.portfolio.value(datum, correct)
def sell(self, ticker, shares=1):
self.portfolio.sell(ticker, self.price(ticker), shares)
def sell_max(self, ticker):
self.portfolio.sell_max(ticker, self.price(ticker))
def buy(self, ticker, shares=1):
self.portfolio.buy(ticker, self.price(ticker), shares)
def buy_max(self, ticker, weight=1.):
self.portfolio.buy_max(ticker, self.price(ticker), weight)
def batch_buy(self, tickers, weights):
if type(weights) is dict:
weights = [weights[ticker] for ticker in tickers]
if sum(weights) > 1:
weights = [w / sum(weights) for w in weights]
self.portfolio.batch_buy(tickers, self.price(tickers), weights)
class Backtest():
def __init__(self,start,end,capital):
self.event = deque()
self.start = start
self.end = end
self.capital = capital
self.dataHandler = None
self.portfolio = None
self.strategy = None
print "Starting new BackTest\n"
def setStrategy(self,strategy):
self.strategy = strategy
print "BackTest Strategy: %s" % self.strategy.description
self.initializeDataHandler()
self.portfolio = Portfolio(self.capital,self.dataHandler)
self.portfolio.setQueue(self.event)
self.strategy.setQueue(self.event)
def initializeDataHandler(self):
symbols = self.strategy.symbols
print "Initializing DataHandler: Found %d symbols" % len(symbols)
self.dataHandler = pandasDataHandler(symbols,self.start,self.end)
print "DataHandler Initialized. Ready to run BackTest\n"
def run(self):
if self.strategy == None:
print "Error: Strategy not set"
return
while(self.data.continue_backtest==True):
#Start of New Trading Day
self.strategy.setup(self.dataHandler)
self.data.updateBars()
market = events.MarketEvent()
self.event.append(market)
self.date = self.data.getDate()
while len(self.event) != 0:
self.parseEvent()
#End of Trading Day
self.portfolio.update(self.date)
def parseEvent(self):
event = self.event.popleft()
if isinstance(event,events.MarketEvent) == True:
self.strategy.calculateSignal(self.dataHandler)
elif isinstance(event,events.SignalEvent) == True:
self.strategy.createOrder(event,self.portfolio)
elif isinstance(event,events.OrderEvent) == True:
self.executeOrder(event)
elif isinstance(event,events.TradeEvent) == True:
self.portfolio.fill(event,self.date)
def executeOrder(self,event):
trade = events.TradeEvent(self.date,event.symbol,'NYSE',
event.quantity,event.price,
event.quantity*event.price)
self.event.append(trade)
