def test_get_all_data_limit():
result1 = get_all_data(limit=2)
assert len(result1) == 2 # samples
assert len(result1[0]) > 0 # rows in sample
assert len(result1[0][0]) == 10 # cols in row
result1 = get_all_data(limit=3)
assert len(result1) == 3 # samples
assert len(result1[0]) > 0 # rows in sample
assert len(result1[0][0]) == 10 # cols in row
def test_book_create(s):
response = s.run(req.book_create, s.app, s.profile, s.book, s.hotkey,
s.active_profile)
assert 'book created' in response['output_kwargs']['msg'].lower()
assert response['output_kwargs']['code'] == 1
data = get_all_data(s.app.db, 'Books')[0]
assert data[0] == s.book
assert data[1] == s.profile
response = s.run(req.book_create, s.app, s.profile, s.book, s.hotkey,
s.active_profile)
assert 'book already' in response['output_kwargs']['msg'].lower()
assert response['output_kwargs']['code'] != 1
book2 = 'asdf'
response = s.run(req.book_create, s.app, s.profile, book2, s.hotkey,
s.active_profile)
assert 'hotkey already' in response['output_kwargs']['msg'].lower()
assert response['output_kwargs']['code'] != 1
response = s.run(req.book_create, s.app, s.profile, book2, '',
s.active_profile)
assert 'hotkey is required' in response['output_kwargs']['msg'].lower()
assert response['output_kwargs']['code'] != 1
# Hit the code path where hokteys would get reloaded, they don't as
# old == new, it's a state based operation, not testing for it atm
hotkey2 = ['f7']
s.run(req.profile_create, s.app, s.profile)
s.run(req.profile_set_active, s.app, s.profile)
response = s.run(req.book_create, s.app, s.profile, book2, hotkey2,
s.profile)
def __init__(self, symbol, dates, start_val, verbose=False):
# Initialize Genetic Algorithm
self.POP_SIZE = 100
self.DNA_SIZE = 8
self.MAX_GENERATIONS = 500
# Mutation probability = 1/mutation_chance
self.mutation_chance = 100
self.mutation_factor = 0.1
self.population_replacement = 0.7
self.best_population_replacement = 0.5
self.verbose = verbose
self.start_val = start_val
self.symbol = symbol
self.dates = dates
self.fitness_dict = {}
# Get data
self.prices_df = util.get_data([symbol],
pd.date_range(dates[0], dates[1]),
addSPY=False).dropna()
# Get Candlestick data
self.df_aux = util.get_all_data(symbol, dates)
self.ohlc = ind.get_ohlc(self.df_aux)
self.patterns_signal, self.trends, self.points_signal, self.sma_signal, self.rsi_signal, self.macd_signal, self.bb_signal = self.get_signals(
self.prices_df, self.ohlc)
def build_xy():
data = get_all_data(limit=samples_limit)
num_timesteps = get_num_timesteps(data)
x = []
y = []
for sample in data:
# sample timestep idx has features from row
old_sample_len = len(sample)
new_sample = np.empty((num_timesteps, num_features)).tolist()
for idx in range(0, num_timesteps):
if idx < old_sample_len:
new_sample[idx] = sample[idx][:num_features] # features
else:
new_sample[idx] = np.zeros(num_features).tolist()
output = sample[0][num_features]
x.append(new_sample)
y.append(output)
x = normalize_arr_3d(x, clamped=True)
x = np.array(x, dtype=np.float32)
y = np.array(y, dtype=np.uint8)
y = one_hot_arrays(y)
return x, y
def testPolicy(self,
symbol,
dates=['2011-1-1', '2011-12-31'],
start_val=100000,
ga_train=False):
#Test a trading policy for a stock wthin a date range and output a trades dataframe.
# Get data
prices_df = util.get_data([symbol],
pd.date_range(dates[0], dates[1]),
addSPY=False).dropna()
# Get Candlestick data
df_aux = util.get_all_data(symbol, dates)
ohlc = ind.get_ohlc(df_aux)
#Generate order signals
order_signals = self.trade_strategy(prices_df, ohlc, ga_train)
# Remove 0 signals
order_signals = order_signals[order_signals != 0.0]
# Create trades dataframe
trades = []
# Double-Down and Double-Up is Active
position = 0
for date in order_signals.index:
if order_signals.loc[date].values == 1:
# Buy Order
if position == 0:
trades.append((date, symbol, "BUY", 1000))
position = 1
elif position == -1:
# Double-Up
trades.append((date, symbol, "BUY", 2000))
position = 1
elif order_signals.loc[date].values == -1:
# Sell Order
if position == 0:
trades.append((date, symbol, "SELL", 1000))
position = -1
elif position == 1:
# Double-Down
trades.append((date, symbol, "SELL", 2000))
position = -1
if date == order_signals.index[-1]:
# Last day, close open positions
last_trade = trades[-1]
trades[-1] = (last_trade[0], last_trade[1], last_trade[2],
last_trade[3] - 1000)
position = 0
self.df_trades = pd.DataFrame(
trades, columns=['Date', 'Symbol', 'Order', 'Shares'])
self.df_trades.set_index('Date', inplace=True)
#pdb.set_trace()
return self.df_trades
def test_hotkey_create(self):
rv = dbapi.hotkey_create(self.db, self.profile, self.book, self.hotkey)
assert rv
data = get_all_data(self.db, 'Hotkeys')[0]
assert data[0] == self.profile
assert data[1] == self.book
assert data[2] == json.dumps(self.hotkey)
rv = dbapi.hotkey_create(self.db, self.profile, self.book, self.hotkey)
assert not rv
def test_hotkey_delete(self):
rv = dbapi.hotkey_delete(self.db, self.profile, self.book, self.hotkey)
assert not rv
dbapi.hotkey_create(self.db, self.profile, self.book, self.hotkey)
rv = dbapi.hotkey_delete(self.db, self.profile, self.book, self.hotkey)
assert rv
data = get_all_data(self.db, 'Hotkeys')
assert not data
def test_page_create(s):
response = s.run(req.page_create, s.app, s.profile, s.book, s.program,
s.specific)
assert 'page created' in response['output_kwargs']['msg'].lower()
assert response['output_kwargs']['code'] == 1
assert response['page_id'] == 1
assert get_all_data(s.app.db, 'Pages')
response = s.run(req.page_create, s.app, s.profile, s.book, s.program,
s.specific)
assert 'page already' in response['output_kwargs']['msg'].lower()
assert response['output_kwargs']['code'] != 1
assert response['page_id'] == 1
def test_page_update_from_id(self):
data_in = {'some': 'data'}
page_id = dbapi.page_create(self.db, self.profile, self.book,
self.program, self.specific, self.loose)
rv = dbapi.page_update_from_id(self.db, page_id + 1, data_in)
assert not rv
rv = dbapi.page_update_from_id(self.db, page_id, data_in)
assert rv
data_out = get_all_data(self.db, 'Pages')[0]
assert data_out[-1] == halt.stringify(data_in)
def test_update_from_id(s):
response = s.run(req.page_update_from_id, s.app, 1, {'k', 'v'})
assert 'does not exist' in response['output_kwargs']['msg'].lower()
assert response['output_kwargs']['code'] != 1
response = s.run(req.page_create, s.app, s.profile, s.book, s.program,
s.specific)
page_id = response['page_id']
update = {'somekey': 'somevalue'}
response = s.run(req.page_update_from_id, s.app, page_id, update)
assert 'page saved' in response['output_kwargs']['msg'].lower()
assert response['output_kwargs']['code'] == 1
data = get_all_data(s.app.db, 'Pages')[0]
assert data[-1] == halt.stringify(update)
def test_page_find_general(s):
dbapi.profile_create(s.app.db, s.profile)
assert dbapi.page_create(s.app.db, s.profile, s.book, s.program, None,
None)
assert dbapi.page_create(s.app.db, s.profile, s.profile, s.program,
'some specifc', None)
bookopts = {'no_process': 'write'}
resp = s.run(req.page_find, s.app.db, s.profile, s.book, s.program,
bookopts)
assert resp
rowid = resp
data = get_all_data(s.app.db, 'Pages')[0]
assert data[1] == s.profile
assert data[2] == s.book
assert data[3] == s.program
assert data[4] == dbapi.UNIQUE_NULL
def test_book_delete(s):
response = s.run(req.book_delete, s.app, 'bad_book', s.profile)
assert 'does not exist' in response['output_kwargs']['msg'].lower()
assert response['output_kwargs']['code'] != 1
response = s.run(req.book_create, s.app, s.profile, s.book, s.hotkey,
s.active_profile)
response = s.run(req.book_delete, s.app, s.book, s.profile)
assert 'book deleted' in response['output_kwargs']['msg'].lower()
assert response['output_kwargs']['code'] == 1
data = get_all_data(s.app.db, 'Books')
assert not data
response = s.run(req.book_delete, s.app, s.book, s.profile)
assert 'does not exist' in response['output_kwargs']['msg'].lower()
assert response['output_kwargs']['code'] != 1
def test_profile_set_and_get_active(s):
profile = 'test'
s.run(req.profile_create, s.app, profile)
response = s.run(req.profile_set_active, s.app, profile)
assert 'profile changed' in response['output_kwargs']['msg'].lower()
assert response['output_kwargs']['code'] == 1
data = get_all_data(s.app.db, 'Profiles')
response = s.run(req.profile_get_active, s.app)
abc = response
response['output_method'] == 'noop'
cond = "where Name == '{}'".format('default')
default_active = halt.load_column(s.app.db, 'Profiles', ('Active', ),
cond)
assert not default_active[0][0]
cond = "where Name == '{}'".format(profile)
test_active = halt.load_column(s.app.db, 'Profiles', ('Active', ),
cond)
assert test_active[0][0]
def test_page_delete(s):
response = s.run(req.page_delete, s.app, s.profile, s.book, 'bad_page',
s.specific, s.loose)
assert 'does not exist' in response['output_kwargs']['msg'].lower()
assert response['output_kwargs']['code'] != 1
response = s.run(req.page_create, s.app, s.profile, s.book, s.program,
s.specific)
response = s.run(req.page_delete, s.app, s.profile, s.book, s.program,
s.specific, s.loose)
assert 'page deleted' in response['output_kwargs']['msg'].lower()
assert response['output_kwargs']['code'] == 1
data = get_all_data(s.app.db, 'Pages')
assert not data
response = s.run(req.page_delete, s.app, s.profile, s.book, s.program,
s.specific, s.loose)
assert 'does not exist' in response['output_kwargs']['msg'].lower()
assert response['output_kwargs']['code'] != 1
def join_data_ticker(df, ticker_data, columns=['Adj Close']):
pass
if __name__ == "__main__":
symbol = "GOOG"
start_val = 100000
testing_pctg = 0.5
#In-sample period
dates = [dt.datetime(2017, 1, 1), dt.datetime(2018, 4, 4)]
strategy = manstratt.ManualStrategyTicktoTick()
# Get data
df = util.get_all_data(symbol, dates)
pos = int(len(df.index) * testing_pctg)
split_date = df.index[pos]
# Use GeneticAlgorithm to optimize signal weights
params = False
gen_alg = ga.GeneticAlgorithm(symbol=symbol,
dates=[dates[0], split_date],
start_val=start_val,
verbose=True)
params, sharpe_ratio = gen_alg.start_ga()
#pdb.set_trace()
ft = FakeTicker(symbol, df, testing_pctg)
# Search for Morning Star patterns
found, signal = is_morning_star_doji(ohlc[i-1], row, ohlc[i+1])
if found:
found_signals.append([mdates.num2date(ohlc[i+1][date]), signal])
if "Abandoned Baby" in patterns:
# Search for Abandoned baby patterns
found, signal = is_abandoned_baby(ohlc[i-1], row, ohlc[i+1])
if found:
found_signals.append([mdates.num2date(ohlc[i+1][date]), signal])
# Search for 2 candle patterns
if "Harami Cross" in patterns:
# Search for Harumi Cross patterns
found, signal = is_harami_cross(row, ohlc[i+1])
if found:
#pdb.set_trace()
found_signals.append([mdates.num2date(ohlc[i+1][date]), signal])
return found_signals
if __name__ == "__main__":
symbols = ['SPY','AAPL', 'GOOG', 'IBM', 'XOM']
obs_dates = ['2011-03-01','2011-04-01']
symbol = "GOOG"
df_aapl = util.get_all_data(symbol, obs_dates)
ohlc = ind.get_ohlc(df_aapl)
for i, row in enumerate(ohlc[:-1]):
if is_harami_cross(row, ohlc[i+1])[0]:
print ("Found Harami Cross!")
print (mdates.num2date(row[0]), row[1:])
print (mdates.num2date(ohlc[i+1][0]), ohlc[i+1][1:])
#pdb.set_trace()
def test_page_create_specific(self):
self.specific = 'something specific'
dbapi.page_create(self.db, self.profile, self.book, self.program,
self.specific, self.loose)
data = get_all_data(self.db, 'Pages')[0]
assert data[4] == self.specific
