def test_ma_strat(ticker, start, end, periods):
# load data
stock = get_ohlcv("", [ticker], start, end, "1mo", save=False)[ticker]
# generate moving average
stock["MA"] = stock["Adj Close"].ewm(span=6, min_periods=6).mean()
# set up portfolio
# strategy portfolio
PORTFOLIO = Portfolio()
values = []
# buy and hold portfolio
SIMPLE_PORTFOLIO = Portfolio()
simple_values = []
# execute strategy
for i in range(len(stock)):
if i == 0:
SIMPLE_PORTFOLIO.add_position(ticker, stock["Adj Close"][i],
SIMPLE_PORTFOLIO.get_cash())
# update prices
PORTFOLIO.advance(ticker, stock["Adj Close"][i])
SIMPLE_PORTFOLIO.advance(ticker, stock["Adj Close"][i])
# determine actions
# is trend bearish?
if stock["Adj Close"][i] < stock["MA"][i]:
if PORTFOLIO.have_position(ticker):
PORTFOLIO.close_position(ticker, stock["Adj Close"][i])
else:
# we are bullish!
if PORTFOLIO.get_cash() > 0:
PORTFOLIO.add_position(ticker, stock["Adj Close"][i],
PORTFOLIO.get_cash())
# update historical values
values.append(PORTFOLIO.get_total_value())
simple_values.append(SIMPLE_PORTFOLIO.get_total_value())
# analyze results
# simple portfolio
d = {'Date': list(stock.index), 'value': simple_values}
df_simple = pd.DataFrame(data=d)
df_simple.set_index("Date", inplace=True)
# quant portfolio
d = {'Date': list(stock.index), 'value': values}
df = pd.DataFrame(data=d)
df.set_index("Date", inplace=True)
print_strategy_summary("Simple",
periods,
df_simple,
price_col_name="value")
print()
print_strategy_summary("Quant", periods, df, price_col_name="value")
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 generate_chart_windowed_rebalancing():
parameters = {}
parameters['primary'] = raw_input("Enter Stock 1: ")
parameters['secondary'] = raw_input("Enter Stock 2: ")
parameters['primary_leverage'] = float(raw_input("Stock 1 Leverage: "))
parameters['primary_ratio'] = float(
raw_input("Enter Stock 1 target ratio: "))
parameters['rebalance_window'] = float(
raw_input("Enter rebalancing window: "))
securities = [
Security(parameters['primary'],
leverage=parameters['primary_leverage']),
parameters['secondary']
]
portfolio = Portfolio(None)
portfolio.generate_new_portfolio(securities)
portfolio.set_investments(
10, {
parameters['primary']: parameters['primary_ratio'],
parameters['secondary']: 1 - parameters['primary_ratio']
})
params = {}
params['primary'] = parameters['primary']
params['secondary'] = parameters['secondary']
params['rebalance_window'] = parameters['rebalance_window']
strategy = Strategies.Strategy(Strategies.windowed_rebalancing, params)
portfolio = execute_simulation(portfolio, strategy)
GraphingTools.plot_portfolio(portfolio, params)
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 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 test_add_stock(self):
p1 = Portfolio(first_name="Julin", last_name="Patel")
p1.add_stock("APPL", 1, 170)
p1.add_stock("SPY", 2, 270)
self.assertEqual(p1.stock_tick_opt, {"APPL": 1, "SPY": 2})
self.assertEqual(p1.stock_tick_avg, {"APPL": 170, "SPY": 270})
def update_portfolio(self, dtm_this_holding_day):
new_port_rcd = [] # list of list of portfolios
for idx in range(self.int_group_num):
new_port_rcd.append([])
# 用复制的方法删除portfolio
for idx in range(self.int_group_num):
for this_port in self.lst_my_portfolios[idx]:
assert isinstance(this_port, Portfolio)
if this_port.int_trading_times >= self.int_holding_day + 1:
pass
else:
new_port_rcd[idx].append(this_port)
self.lst_my_portfolios = new_port_rcd
# 增加portfolio
if dtm_this_holding_day in self.lst_trading_days:
if dtm_this_holding_day in self.dct_dct_my_port.keys():
for idx in range(self.int_group_num):
new_port = Portfolio(
self.dct_dct_my_port[dtm_this_holding_day][idx],
dtm_this_holding_day, self.mtx_stk_ret,
self.mtx_stk_cap_shift1)
if self.str_description == 'value_weight_1fresult':
new_port.update_beta_weight_1f(self.dct_beta_f1_shift1)
if 'value_weight_2fresult' in self.str_description:
new_port.update_beta_weight_2f(self.dct_beta_f2_shift1)
# print('add'+str(len(new_port.lst_int_this_port)))
self.lst_my_portfolios[idx].append(new_port)
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 __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 main():
# Delete portfolio.db if it exists
os.remove("portfolio.db")
print("portfolio.db removed successfully")
# Get data paths
stock_filename = "data_stocks.csv"
bond_filename = "data_bonds.csv"
# Initialize dataReader
dataReader = DataReader(stock_filename, bond_filename)
# Get stock and bond data
stockData = dataReader.getStockData()
bondData = dataReader.getBondData()
# Initialize an investor
investor = Investor("Bob", "Smith", "123 Fake St, Denver, CO 80221",
"303.777.1234")
# Initialize a portfolio
portfolio = Portfolio(investor)
# Add the stocks and bonds to the portfolio
portfolio.addStocks(stockData)
portfolio.addBonds(bondData)
# Initialize a report
report = Report(portfolio)
# Print the report
report.print()
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 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
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 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 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 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 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 test_bars(length=50):
latch = DataLatch(3)
s1_order_q = DQueue()
s1_fill_q = DQueue()
strat_name = 'test_%d' % length
strategy = MStrategy(strat_name, strategy_params={'length': length})
strategy.bar_interval = 0
strategy.IN_fills = s1_fill_q
strategy.OUT_orders = s1_order_q
strategy.latch = latch
porto_name = 'portfolio_%d' % length
portfolio = Portfolio(porto_name, None)
portfolio.latch = latch
portfolio.add(strategy)
exchange = Exchange()
exchange.IN_orders = portfolio.OUT_orders
exchange.OUT_fills = portfolio.IN_fills
exchange.latch = latch
exchange.start()
portfolio.start()
strategy.start()
log.info("START JOB %s = %s" % (porto_name, datetime.datetime.now()))
simData = DataFeedBars('20100315.SPY.1m.csv')
for market_data in simData:
latch.trap(market_data)
## ORDER MATTERS!
## this allows submit-fill loop to happen in a single on_data() event
strategy.on_data(market_data)
portfolio.on_data(market_data)
exchange.on_data(market_data)
## do any final processing
#strategy.flush()
exchange.shutdown()
portfolio.shutdown()
strategy.shutdown()
exchange.join()
portfolio.join()
strategy.join()
# portfolio.stats(write_data=True)
filename = 'TEST_BAR_X_%d.xls' % length
port_stats = portfolio.stats(filename=filename)
print 'portfolio stats'
pprint(port_stats)
log.info("END JOB %s = %s" % (porto_name, datetime.datetime.now()))
return portfolio
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 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 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 generate_portfolios(self, portfolio_changes):
for change in portfolio_changes:
if change not in self.portfolios:
self.portfolios[change] = Portfolio(
self.members_list,
filing_date=change,
min_underlying_weight=self.min_underlying_weight,
min_port_weight=self.min_port_weight,
max_port_size=self.max_port_size).portfolio
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 createPortfolio():
'''
Create the portfolio
'''
portfolioId = str(ObjectId())
userId = request.get_json().get("userId", None)
if portfolioId == None or userId == None:
logging.error("The portfolio ID or the user ID is undefined")
abort(make_response("The portfolio ID, the user ID is undefined", 500))
portfolioPath = os.path.join(config.portfoliosDir, str(portfolioId))
imagesPath = os.path.join(portfolioPath, str("images"))
try:
if not os.path.exists(portfolioPath):
os.makedirs(portfolioPath)
os.makedirs(imagesPath)
except OSError:
logging.error("can't create " + portfolioPath + " or " + imagesPath)
pass
portfolio = Portfolio(portfolioId, userId)
# minimal requierements
pseudo = request.get_json().get("projectTitle", None)
fieldActivity = request.get_json().get('fieldActivity', None)
place = request.get_json().get('place', None)
networking = request.get_json().get('networking', None)
availability = request.get_json().get('availability', None)
contact = request.get_json().get('contact', None)
# Data
if pseudo is not None:
portfolio.pseudo = pseudo
if fieldActivity is not None:
portfolio.fieldActivity = fieldActivity
if place is not None:
portfolio.place = place
if networking is not None:
portfolio.networking = networking
if availability is not None:
portfolio.availability['begin'] = availability['begin']
portfolio.availability['end'] = availability['end']
if contact is not None:
portfolio.contact['name'] = contact['name']
portfolio.contact['phone'] = contact['phone']
portfolio.contact['mail'] = contact['mail']
config.portfolioTable.insert(portfolio.__dict__)
requestResult = config.portfolioTable.find_one(
{"portfolioId": portfolioId})
return mongodoc_jsonify(requestResult)
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 run_model(asset_list,
returns_style='calc',
optimization_style='sharpe',
opt_window_start=datetime.date(2018, 10, 28),
opt_time_range=4,
filter_type='expirydate',
expiry_range=52,
reopt_freq=2,
leverage=1,
asset_types='options'):
"""
Inputs: list of assets, returns style, optimization style, optimmization window start date, optimization time range,
filter type, expriry_range, re-optimization frequency, leverage
date ranges are in weeks
:return:
"""
myport = Portfolio()
rets = 'calcreturns'
print(asset_types)
for contract in asset_list:
print(contract)
if asset_types == 'options':
if contract in common_port.holdings:
contracts = common_port.find(contract)
for c in contracts:
if c is not contract:
myport.holdings[c] = common_port.holdings[c]
else:
mT.get_one_option(contract, myport)
elif asset_types == 'stocks':
if contract in common_port.holdings:
myport.holdings[contract] = common_port.holdings[contract]
else:
mT.get_one_stock(contract, myport)
elif asset_types == 'mixed':
if contract in common_port.holdings:
contracts = common_port.find(contract)
for c in contracts:
myport.holdings[c] = common_port.holdings[c]
else:
mT.get_one_option(contract, myport)
mT.get_one_stock(contract, myport)
try:
if optimization_style is 'sharpe':
print('modeling')
result_dict = myport.run(
opt_window_start, opt_time_range,
opt_window_start + datetime.timedelta(days=7 * expiry_range),
reopt_freq)
except any:
abort(404, 'error building model')
return flask.jsonify(result_dict)
def main():
CashinHand = 1000000
BaseRate = 0.01
myBook = Portfolio(CashinHand, BaseRate)
myBookBT = Backtest(myBook, 0.25, 25, 0.01)
myBookBT.BT()
#print(myBookBT.output)
thefile = open('output.txt', 'w')
for item in myBookBT.output:
thefile.write("%s\n" % item)
thefile.close()
def test_multiple_symbols():
latch = DataLatch(3)
s1_order_q = DQueue()
s1_fill_q = DQueue()
strategy = MStrategy('test_strategy', strategy_params={'length': 10})
strategy.IN_fills = s1_fill_q
strategy.OUT_orders = s1_order_q
strategy.latch = latch
portfolio = Portfolio('test_porto', None)
portfolio.latch = latch
portfolio.add(strategy)
exchange = Exchange()
exchange.IN_orders = portfolio.OUT_orders
exchange.OUT_fills = portfolio.IN_fills
exchange.latch = latch
exchange.start()
portfolio.start()
strategy.start()
log.info("START JOB= %s" % datetime.datetime.now())
## combined file of SPY, IWM, and QQQQ
simData = DataFeedIntraday('20100315.XXX.csv')
for market_data in simData:
latch.trap(market_data)
## ORDER MATTERS!
## this allows submit-fill loop to happen in a single on_data() event
strategy.on_data(market_data)
portfolio.on_data(market_data)
exchange.on_data(market_data)
## do any final processing
#strategy.flush()
exchange.shutdown()
portfolio.shutdown()
strategy.shutdown()
exchange.join()
portfolio.join()
strategy.join()
log.info("STAT JOB= %s" % datetime.datetime.now())
port_stats = portfolio.stats(filename='TESTER.xls')
pprint(port_stats)
log.info("END JOB= %s" % datetime.datetime.now())
log.info("LEN DATA JOB= %s" % simData.count)
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)
