def __init__(self, start_date, end_date, initial_position, market, params, h5file=None):
Strategy.__init__(self, start_date, end_date, initial_position, market, params, h5file)
for symbol in initial_position.keys():
if symbol == "$":
continue
self.addIndicator(symbol, "value", SimpleValue())
self.addSpecificIndicator(symbol, "peak", PeakTrough())
date = getPrevTradingDay(market, start_date, symbol)
#date = getNextTradingDay(start_date, symbol)
self.peakDate = date
self.troughDate = date
ticker = market[symbol]
if ticker[date] == None:
self.max_value = 0
self.min_value = 1000
else:
self.max_value = ticker[date].adjhigh
self.min_value = ticker[date].adjlow
self.updateSpecificIndicator(symbol, 'peak', start_date, (self.max_value, 1))
self.updateIndicators(start_date)
self.win_point = params['win']
self.loss_point = params['loss']
self.low_to_high = 0
self.high_to_low = 0
self.upTrend = 0
self.downTrend = 0
def CreateString(n, k):
initialValue = 'A' * n
char_list = list(initialValue)
h = Strategy(k)
candidates = SortedListWithKey(key=h.evaluate_node)
candidates.add(char_list)
altura = 0
while altura < k+1:
try:
candidate = candidates.pop(0)
punctuation = h.evaluate_node(candidate)
if punctuation == 0:
return ''.join(candidate)
l = expand(candidate)
for expanded in l:
punctuation = h.evaluate_node(expanded)
if punctuation >= 0:
candidates.add(expanded)
altura += 1
except IndexError:
return ''
return ''
def __init__(self, start_date, end_date, initial_position, market, params, h5file=None):
Strategy.__init__(self, start_date, end_date, initial_position, market, params, h5file)
during = params['during']
self.history = [1000.0 for x in xrange(during+1)]
for symbol in initial_position.keys():
if symbol == "$":
continue
self.addIndicator(symbol, "value", SimpleValue())
try:
short = params['short']
except KeyError:
short = Trending.DEF_SHORT_DAYS
self.addIndicator(symbol, "short", EMA(short))
try:
long_ = params['long']
except KeyError:
long_ = Trending.DEF_LONG_DAYS
self.addIndicator(symbol, "long", EMA(long_))
try:
backfill = params['backfill']
except KeyError:
backfill = long_
d = start_date - (backfill * ONE_DAY)
self.updateIndicators(d, start_date)
self.win_point = params['win']
self.loss_point = params['loss']
def test_precompute():
ticks = load_ticks('dc', 'pp', 2015, range(9,10), use_cache=True)
s = Strategy(ticks, 3.75, show_freq=None)
ind = PivotProfile(s, 5*60*2, int(1 * 3.75 * 60 * 60 * 2))
t0 = time.time()
ind.precompute()
t1 = time.time()
print 't_precompute =', t1 - t0, 'sec'
s.add_indicator(ind)
t0 = time.time()
s.run()
t1 = time.time()
print 't =', t1 - t0, 'sec'
s2 = Strategy(ticks, 3.75, show_freq=None)
ind2 = PivotProfile(s2, 5*60*2, int(1 * 3.75 * 60 * 60 * 2))
s2.add_indicator(ind2)
t0 = time.time()
s2.run()
t1 = time.time()
print 't =', t1 - t0, 'sec'
sal = ind.saliency[0][ind.saliency[3]:-ind.saliency[3]]
sal2 = ind2.saliency[0][ind2.saliency[3]:-ind2.saliency[3]]
print np.abs(sal - sal2).mean(), np.abs(sal - sal2).max(), np.abs(sal).mean()
def __init__(self, start_date, end_date, initial_position, market, params, h5file=None):
Strategy.__init__(self, start_date, end_date, initial_position, market, params, h5file)
self.diff = {}
for symbol in initial_position.keys():
if symbol == "$":
continue
self.diff[symbol] = [0.0]
self.addIndicator(symbol, "value", SimpleValue())
try:
period = params['period']
except KeyError:
period = averageSystem.DEF_PERIOD
self.addIndicator(symbol, "MA", SMA(period))
try:
short = params['short']
except KeyError:
short = Trending.DEF_SHORT_DAYS
self.addIndicator(symbol, "short", EMA(short))
try:
long_ = params['long']
except KeyError:
long_ = Trending.DEF_LONG_DAYS
self.addIndicator(symbol, "long", EMA(long_))
try:
backfill = params['backfill']
except KeyError:
backfill = period
d = start_date - (backfill * ONE_DAY)
self.updateIndicators(d, start_date)
self.win_point = params['win']
self.loss_point = params['loss']
self.pre = 0
def __init__(self, start_date, end_date, initial_position, market, params, h5file=None):
Strategy.__init__(self, start_date, end_date, initial_position, market, params, h5file)
self.diff = {}
for symbol in initial_position.keys():
if symbol == "$":
continue
self.diff[symbol] = [0.0]
self.addIndicator(symbol, "value", SimpleValue())
try:
short = params['short']
except KeyError:
short = Trending.DEF_SHORT_DAYS
self.addIndicator(symbol, "short", EMA(short))
try:
long_ = params['long']
except KeyError:
long_ = Trending.DEF_LONG_DAYS
self.addIndicator(symbol, "long", EMA(long_))
'''
try:
rsi = params['rsi']
except KeyError:
rsi = Trending.DEF_RSI_PERIOD
self.addIndicator(symbol, "rsi", RSI(rsi))
'''
# Backfill the indicators
try:
backfill = params['backfill']
except KeyError:
backfill = long_
d = start_date - (backfill * ONE_DAY)
self.updateIndicators(d, start_date)
def __init__(self, settings, watchlist, trademanager):
Strategy.__init__(self, watchlist, trademanager)
self.minprice = settings.getfloat("Strategy", "minprice")
self.minvolume = settings.getfloat("Strategy", "minvolume")
self.fastma = settings.getint("Strategy", "fastma")
self.slowma = settings.getint("Strategy", "slowma")
self.atrStop = self._getfloatsetting(settings, "Strategy", "atrStop")
self.percentStop = self._getfloatsetting(settings, "Strategy", "percentStop")
def __init__(self, settings, watchlist, tradeManager):
Strategy.__init__(self, watchlist, tradeManager)
self.minprice = settings.getfloat("Strategy", "minprice")
self.minvolume = settings.getint("Strategy", "minvolume")
self.mingap = settings.getfloat("Strategy", "mingap")
self.dailysmatrendfilter = self._getintsetting(settings,"Strategy", "dailysmatrendfilter")
self.target = self._getfloatsetting(settings, "Strategy", "target")
self.minhour = settings.getint("Strategy", "minhour")
self.maxhour = settings.getint("Strategy", "maxhour")
self.donchianstop = settings.getint("Strategy", "donchianstop")
class TestStrategy(unittest.TestCase):
def setUp(self):
self.problem = Problem()
self.strategy = Strategy()
def test_execute(self):
try:
self.strategy.execute(self.problem)
except UndefinedError:
pass
else:
self.fail('Did not see UndefinedError')
def __init__(self, settings, watchlist, tradeManager):
Strategy.__init__(self, watchlist, tradeManager)
self.minprice = settings.getfloat("Strategy", "minprice")
self.timescale = settings.getint("Strategy", "timescale")
self.period = settings.getint("Strategy", "period")
self.bandwidth = settings.getfloat("Strategy", "bandwidth")
self.bandStop = self._getfloatsetting(settings, "Strategy", "bandStop")
self.percentStop = self._getfloatsetting(settings, "Strategy","percentStop")
self.sma = self._getintsetting(settings, "Strategy", "smafilter")
self.exitAtOtherBand = self._getboolsetting(settings, "Strategy", "exitAtOtherBand")
self.doLong = self._getboolsetting(settings, "Strategy", "doLong")
self.doShort = self._getboolsetting(settings, "Strategy", "doShort")
def test_macd():
ticks = load_ticks('dc', 'pp', 2015, range(9,10), use_cache=True)
s = Strategy('pp09_macd', ticks, 3.75)
inds = [MACD(s, 1*60*2, 5*60*2, standardized=False, escape_opening=1),
MACD(s, 2*60*2, 10*60*2, standardized=False, escape_opening=1),
MACD(s, 10*60*2, 60*60*2, standardized=False, escape_opening=0)
]
for ind in inds:
s.add_indicator(ind)
s.run()
class Trader(object):
'''
'''
last_id = -1
@classmethod
def new_id(cls):
cls.last_id = cls.last_id + 1
return cls.last_id
def __init__(self, datafeed, broker, opening_bal, instrument, strategy, start_date, end_date):
'''
'''
self.id = Trader.new_id()
self.instrument = instrument
self.start_date = start_date
self.end_date = end_date
self.datafeed = datafeed
self.opening_bal = opening_bal
self.broker = broker
self.orderQ = None
self.receiptQ = None
self.term_req_Q = None
self.term_notice_Q = None
self.broker.register_trader(self)
self.order_receipts = []
self.load_strategy()
def load_strategy(self):
'''
called by simulator
'''
self.strategy = Strategy(self, self.instrument, self.start_date, self.end_date)
def submit_order(self, order):
'''
submit order to broker for execution
place on orderQ
'''
order.trader_id = self.id
self.orderQ.put(order)
def execute_strategy(self, date):
'''
called by simulator
'''
self.strategy.execute(date)
def processOfferQuery(self, aQueryInConstruction): sStrategy = aQueryInConstruction.sStrategy try: aStrategy = next(sc for sc in Strategy.__subclasses__() if sc.strategyName() == aQueryInConstruction.sStrategy) aQueryInConstruction.strategy = aStrategy() except Exception: raise IllegalStrategy(aQueryInConstruction.sStrategy) return aQueryInConstruction
def test_output(year=2015, month_range=range(1, 13), name=''):
for exchange, commodity, tick_size, hours_per_day in futures:
ticks = load_ticks(exchange, commodity, year, month_range)
name = base_dir+commodity+str(year%100)+str(month_range[0]).zfill(2)+'-'+str(year%100)+str(month_range[-1]).zfill(2)+'_pivot'+name
s = Strategy(name, ticks, tick_size, hours_per_day, save_freq=10)#, show_freq=10)
# ind_xs = SRProfile(s, 0.5*60*2, int(30*60*2))
ind_s = PivotProfile(s, 5*60*2, int(1 * hours_per_day * 60 * 60 * 2 * 1.5))
ind_m = PivotProfile(s, 30*60*2, int(5 * hours_per_day * 60 * 60 * 2 * 1.5))
for ind in [
ind_m,
ind_s,
# ind_xs,
]:
ind.precompute()
s.add_indicator(ind)
s.run()
return s
def mill(traj, z_start=0, z_stop=None, z_step = 1, FF=3000, FZ=200, options=None):
'вырезаем траекторию'
from strategy import Strategy
from tool import Tool
cut = Strategy()
t = Tool()
t.F = FF
t.FZ = FZ
#берем опции
xx = get_option(options, 'x', 0)
yy = get_option(options, 'y', 0)
sc = get_option(options, 'scale', 1)
ang = get_option(options, 'angle', 0)
if z_stop == None: #просто один слой там, где скажут
cut.mill(traj, tool=t, x=xx, y=yy, scale=sc, angle=ang, options=options)
return
opt = options.copy()
z = z_start
while z >= z_stop:
opt['z'] = z
cut.mill(traj, tool=t, x=xx, y=yy, scale=sc, angle=ang, options=opt)
z -= z_step
if z + z_step > z_stop: #дорезаем остатки
opt['z'] = z_stop
cut.mill(traj, tool=t, x=xx, y=yy, scale=sc, angle=ang, options=opt)
def strategies(self):
cherrypy.response.headers["Content-Type"] = "text/plain"
subclasses = Strategy.__subclasses__()
subclassNameList = []
for aSubclass in subclasses:
subclassNameList.append(aSubclass.strategyName())
return json.dumps(subclassNameList, ensure_ascii=False)
def test_output(year=2016, month_range=range(1, 6), exp_name=''):
for exchange, commodity, tick_size, hours_per_day in futures:
ticks = load_ticks(exchange, commodity, year, month_range)
name = base_dir+commodity+str(year%100)+str(month_range[0]).zfill(2)+'-'+str(year%100)+str(month_range[-1]).zfill(2)+'_common'+exp_name
s = Strategy(name, ticks, tick_size, hours_per_day, save_freq=10)#, show_freq=10)
inds = [
# MACD(s, 10, 1*60*2, escape_opening=0),
# MACD(s, 10, 5*60*2, escape_opening=0),
# MACD(s, 1*60*2, 10*60*2, escape_opening=0),
# MACD(s, 5*60*2, 30*60*2, escape_opening=0),
# MACD(s, 5*60*2, 60*60*2, escape_opening=0),
# MACD(s, 5*60*2, 120*60*2, escape_opening=0),
# MACD(s, 5*60*2, 240*60*2, escape_opening=0),
# MA(s, 5*2),
# MA(s, 1*60*2),
# MA(s, 5*60*2),
# MA(s, 10*60*2),
# MA(s, 30*60*2),
# MA(s, 60*60*2),
# MA(s, 120*60*2),
# MA(s, 240*60*2),
PastXtrm(s, 5*60*2),
PastXtrm(s, 10*60*2),
PastXtrm(s, 30*60*2),
PastXtrm(s, 60*60*2),
PastXtrm(s, 120*60*2),
PastXtrm(s, 240*60*2),
FutureXtrm(s, 5*60*2),
FutureXtrm(s, 10*60*2),
FutureXtrm(s, 30*60*2),
FutureXtrm(s, 60*60*2),
FutureXtrm(s, 120*60*2),
FutureXtrm(s, 240*60*2),
TimeInfo(s)
]
for ind in inds:
s.add_indicator(ind)
print 'Running', name
with Timer() as t:
s.run()
print 'Run took %f sec.' % t.interval
return s
def make_move(self, x=None, y=None):
Player.make_move(self, x, y)
# Calculate move
liberties = Game.liberties(self.player, self.state)
#def apply_strat(strategy, mult=1, heur=None):
# return strategy.apply(self.player, self.state, liberties, mult, heuristic=heur)
heur = None
for strat, mult in self.strats:
heur = strat.apply(self.player, self.state, liberties, mult, heur)
x, y = Strategy.run(heur)
self.game.move(x, y)
class Agent:
POPULATION_SIZE = 15
SIGMA = 0.5
LEARNING_RATE = 0.3
def __init__(self, model, timeseries, skip, initial_money, real_trend,
minmax):
self.model = model
self.timeseries = timeseries
self.skip = skip
self.real_trend = real_trend
self.initial_money = initial_money
self.es = Strategy(
self.model.get_weights(),
self.get_reward,
self.POPULATION_SIZE,
self.SIGMA,
self.LEARNING_RATE,
)
self.minmax = minmax
self._initiate()
def _initiate(self):
# i assume first index is the close value
self.trend = self.timeseries[0]
self._mean = np.mean(self.trend)
self._std = np.std(self.trend)
self._inventory = []
self._capital = self.initial_money
self._queue = []
self._scaled_capital = self.minmax.transform([[self._capital, 2]])[0,
0]
def reset_capital(self, capital):
if capital:
self._capital = capital
self._scaled_capital = self.minmax.transform([[self._capital, 2]])[0,
0]
self._queue = []
self._inventory = []
def change_data(self, timeseries, skip, initial_money, real_trend, minmax):
self.timeseries = timeseries
self.skip = skip
self.initial_money = initial_money
self.real_trend = real_trend
self.minmax = minmax
self._initiate()
def act(self, sequence):
decision = self.model.predict(np.array(sequence))
return np.argmax(decision[0])
def act_softmax(self, sequence):
decision = self.model.predict(np.array(sequence))
return np.argmax(decision[0]), softmax(decision)[0]
def get_state(self, t, inventory, capital, timeseries):
state = get_state(timeseries, t)
len_inventory = len(inventory)
if len_inventory:
mean_inventory = np.mean(inventory)
else:
mean_inventory = 0
z_inventory = (mean_inventory - self._mean) / self._std
z_capital = (capital - self._mean) / self._std
concat_parameters = np.concatenate(
[state, [[len_inventory, z_inventory, z_capital]]], axis=1)
return concat_parameters
def get_reward(self, weights):
initial_money = self._scaled_capital
starting_money = initial_money
invests = []
self.model.weights = weights
inventory = []
state = self.get_state(0, inventory, starting_money, self.timeseries)
for t in range(0, len(self.trend) - 1, self.skip):
action = self.act(state)
if action == 1 and starting_money >= self.trend[t]:
inventory.append(self.trend[t])
starting_money -= self.trend[t]
elif action == 2 and len(inventory):
bought_price = inventory.pop(0)
starting_money += self.trend[t]
invest = ((self.trend[t] - bought_price) / bought_price) * 100
invests.append(invest)
state = self.get_state(t + 1, inventory, starting_money,
self.timeseries)
invests = np.mean(invests)
if np.isnan(invests):
invests = 0
score = (starting_money - initial_money) / initial_money * 100
return invests * 0.7 + score * 0.3
def fit(self, iterations, checkpoint):
self.es.train(iterations, print_every=checkpoint)
def buy(self):
initial_money = self._scaled_capital
starting_money = initial_money
inventory = bitmex_back.get_position('XBTUSD')
state = self.get_state(0, inventory, starting_money, self.timeseries)
fees = 0
states_sell = 0
states_buy = 0
for t in range(0, len(self.trend) - 1, self.skip):
action, prob = self.act_softmax(state)
print(t, prob)
if action == 1 and starting_money >= self.trend[t] and t < (
len(self.trend) - 1 - window_size):
bitmex_back.place_order(price=self.real_trend[t],
type="Market",
qty=1,
stopPx=self.real_trend[t] * 1.03)
updated_balance = [i['walletBalance']
for i in balances[-1]][-1]
timestamp = [i['timestamp'] for i in balances[-1]][-1]
fee_for_trade = [i['fee'] for i in balances[-1]][-1]
fees += fee_for_trade
states_buy += 1
print('day %d: buy 1 unit at price %f, total balance %f' %
(timestamp, self.real_trend[t], updated_balance))
elif action == 2 and len(inventory):
bitmex_back.place_order(price=self.real_trend[t],
type="Market",
qty=-1,
stopPx=self.real_trend[t] * 0.97)
updated_balance = [i['walletBalance']
for i in balances[-1]][-1]
investment_updated = [i['unrealizedPnL'] for i in balances[-1]]
investment = investment_updated[0]
timestamp = [i['timestamp'] for i in balances[-1]][-1]
fee_for_trade = [i['fee'] for i in balances[-1]][-1]
fees += fee_for_trade
states_sell += 1
print(
'day %d, sell 1 unit at price %f, investment %f %%, total balance %f,'
% (timestamp, self.real_trend[t], investment,
updated_balance))
state = self.get_state(t + 1, inventory, starting_money,
self.timeseries)
unrealized_gains = [i['unrealizedPnL'] for i in balances[-1]][-1]
realized_gains = [i['realizedPnL'] for i in balances[-1]][-1]
total_gains = unrealized_gains + realized_gains - fees
return states_buy, states_sell, total_gains, fees
def __init__(self, search_order="DLRU"):
search_order = search_order[::-1]
Strategy.__init__(self, search_order=search_order)
from strategy import Strategy, BLACK, WHITE
from OthelloStrategy5_padusuma import OthelloStrategy
ai = Strategy()
ai2 = OthelloStrategy()
from Othello_Core import *
core = OthelloCore()
import random
import time
#############################################################
# client.py
# a simple othello client
# plays 2 strategies against each other and keeps score
# imports strategies from "strategies.py" as ai
# rest of functionality is stored in core.py
#
# SRINIDHI KRISHNAN
############################################################
B_STRATEGY = ai.human_strategy()
W_STRATEGY = ai.minimax_strategy(6)
ROUNDS = 10
SILENT = False
# see core.py for constants: MAX, MIN, TIE
def play(strategy_b, strategy_w, first=BLACK, silent=True):
"""
Plays strategy_b vs. strategy_w, beginning with first
def __init__(self):
'''
Constructor
'''
Strategy.__init__(self)
def __init__(self, strategy=Strategy()):
self._strategy = strategy
def test_stream_price(self):
s = Strategy(start_amount=1000, sl=0.02, tpmulti=2)
p1 = Price([datetime(2015, 12, 31, 12, 00), 10])
s.stream_price(p1)
self.assertEqual(len(s.trades), 1)
# Remaining amount comes by subtracting first transaction total amount.
self.assertEqual(s.status['remaining_amount'], 900)
self.assertEqual(s.status['open_trades_count'], 1)
trx1 = s.trades[0]
self.assertEqual(trx1.get('entry_amount'), 100)
self.assertEqual(trx1.get('stop_loss_price'), 8)
self.assertEqual(trx1.get('take_profit_price'), 14)
# Balance count should be equal to transactions count.
self.assertEqual(len(s.balances), len(s.trades))
self.assertTrue(isinstance(s.balances[0][0], datetime))
##
# Add second price tick.
##
p2 = Price([datetime(2015, 12, 31, 12, 30), 12])
s.stream_price(p2)
# Remaining amount comes by subtracting first transaction total amount.
self.assertEqual(s.status['remaining_amount'], 780)
self.assertEqual(s.status['open_trades_count'], 2)
# Last record of balance should be updated.
self.assertEqual(s.current_price.get('value'), 12)
self.assertEqual(len(s.balances), len(s.trades))
self.assertEqual(s.balances[-1][1], 1020)
##
# Add third price
##
p3 = Price([datetime(2015, 12, 31, 13, 00), 14])
s.stream_price(p3)
# Remaining amount comes by subtracting first transaction total amount.
self.assertEqual(s.status['remaining_amount'], 780)
self.assertEqual(s.status['open_trades_count'], 2)
self.assertEqual(s.status['closed_trades_count'], 1)
# Last record of balance should be updated.
self.assertEqual(s.current_price.get('value'), 14)
self.assertEqual(len(s.balances), len(s.trades))
self.assertEqual(s.balances[-1][1], 1060)
##
# Add fourth price
##
p4 = Price([datetime(2015, 12, 31, 13, 30), 16])
s.stream_price(p4)
self.assertEqual(s.status['remaining_amount'], 780)
self.assertEqual(s.status['open_trades_count'], 2)
self.assertEqual(s.status['closed_trades_count'], 2)
self.assertEqual(s.current_price.get('value'), 16)
self.assertEqual(len(s.balances), len(s.trades))
self.assertEqual(s.balances[-1][1], 1100)
# Add 10 more prices with the same price. No more than 10
# positions should be opened, because of insufficient money.
pdate = datetime(2015, 12, 31, 13, 30)
for i in range(10):
min_30 = timedelta(minutes=30)
pdate = pdate + min_30
p = Price([pdate, 16])
s.stream_price(p)
self.assertEqual(s.status['remaining_amount'], 140)
self.assertEqual(s.status['open_trades_count'], 6)
self.assertEqual(s.status['closed_trades_count'], 2)
self.assertEqual(s.current_price.get('value'), 16)
self.assertEqual(len(s.balances), 14)
self.assertEqual(s.balances[-1][1], 1100)
# Create decreasing more prices with constantly decreasing prices
# calculate the result of trading.
p15 = Price([pdate + timedelta(minutes=30), 15])
s.stream_price(p15)
self.assertEqual(s.status['remaining_amount'], 140)
self.assertEqual(s.status['open_trades_count'], 6)
self.assertEqual(s.status['closed_trades_count'], 2)
self.assertEqual(len(s.balances), 15)
self.assertEqual(s.balances[-1][1], 1040)
p16 = Price([pdate + timedelta(minutes=30), 14])
s.stream_price(p16)
self.assertEqual(s.status['remaining_amount'], 700)
self.assertEqual(s.status['open_trades_count'], 2)
self.assertEqual(s.status['closed_trades_count'], 7)
self.assertEqual(len(s.balances), 16)
self.assertEqual(s.balances[-1][1], 980)
p17 = Price([pdate + timedelta(minutes=30), 13])
s.stream_price(p17)
self.assertEqual(s.status['remaining_amount'], 570)
self.assertEqual(s.status['open_trades_count'], 3)
self.assertEqual(s.status['closed_trades_count'], 7)
self.assertEqual(len(s.balances), 17)
self.assertEqual(s.balances[-1][1], 960)
p18 = Price([pdate + timedelta(minutes=30), 12])
s.stream_price(p18)
self.assertEqual(s.status['remaining_amount'], 690)
self.assertEqual(s.status['open_trades_count'], 2)
self.assertEqual(s.status['closed_trades_count'], 9)
self.assertEqual(len(s.balances), 18)
self.assertEqual(s.balances[-1][1], 930)
p19 = Price([pdate + timedelta(minutes=30), 11])
s.stream_price(p19)
self.assertEqual(s.status['remaining_amount'], 690)
self.assertEqual(s.status['open_trades_count'], 2)
self.assertEqual(s.status['closed_trades_count'], 10)
self.assertEqual(len(s.balances), 19)
self.assertEqual(s.balances[-1][1], 910)
p20 = Price([pdate + timedelta(minutes=30), 10])
s.stream_price(p20)
self.assertEqual(s.status['remaining_amount'], 690)
self.assertEqual(s.status['open_trades_count'], 2)
self.assertEqual(s.status['closed_trades_count'], 11)
self.assertEqual(len(s.balances), 20)
self.assertEqual(s.balances[-1][1], 890)
# Test stats calculation.
self.assertEqual(s.stats['trades_count'], 13)
self.assertEqual(s.stats['positive_count'], 2)
self.assertEqual(s.stats['negative_count'], 9)
self.assertEqual(s.stats['balance_highest'], 1100)
self.assertEqual(s.stats['balance_lowest'], 890)
self.assertEqual(s.stats['positive_max_in_row'], 2)
self.assertEqual(s.stats['negative_max_in_row'], 9)
def __traverse_files(self):
count = 0
for root, directories, files in walk(self.__source_directory):
for filename in files:
file_dir = join(root, filename)
__strat = Strategy(file_dir, self.__destination_directory)
#output = backTest.resample("1Min")
#exit()
#GROUP RESAMPLE TO PICKLE
#groupResample(2015, 1, 6, "1H", "EUR_USD")
#exit()
# READ PICKLE INTO DATAFRAME (prices)
#backtest = Backtest("historical/EUR_USD_Week3.csv_1Min-OHLC.pkl",backtestSettings,leverage,closeDictionary,backtestSettings['positions'])
backtest = Backtest("historical/EUR_USD_2015_1_through_12.pkl",
backtestSettings, leverage, backtestPositions)
#backtest = Backtest("historical/EUR_USD_2015_1_through_12.pkl",backtestSettings,leverage,closeDictionary,backtestSettings['positions'])
prices = backtest.readPickle()
# INSTANTIATE STRATEGY
strategy = Strategy(backtestPositions, priceQueue, backtestSettings,
strategySettings)
# LOOP THROUGH PRICES
i = 0 # for displaying trades in a scatterplot
for index, row in prices:
# SKIP ERRORS IN PICKLE
if np.isnan(row['Buy']) or np.isnan(row['Sell']):
continue
# 0.A: ADD CURRENT PRICE TO QUEUE
priceQueue = strategy.doQueue(
priceQueue, strategySettings["queuePeriod"],
row) # add current price to queue, along with stats
longQueue = strategy.doQueue(
longQueue, strategySettings["longQueuePeriod"],
next_group.append(Individual(st=Strategy(sim_code=new_bro)))
next_group.append(Individual(st=Strategy(sim_code=new_sis)))
print()
return next_group
# 生成初始群体
group = []
for group_index in range(group_size):
# 生成随机代码
gene_list = []
for gene_index in range(gene_size):
gene_list.append(str(random.randint(0, 6)))
sim_code = "".join(gene_list)
group.append(Individual(st=Strategy(sim_code=sim_code)))
for evo_num in range(evo_time):
print("evolution----------", evo_num)
group = genetic_algorithm(group)
for ele in group:
gl = []
for i in range(10000):
b_map = Map(max_x=10, max_y=10, bean_rate=0.5, wall_rate=0).inner_map
for j in range(action_time):
ele.movement(bean_map=b_map)
gl.append(ele.goal)
ele.goal = 0
ans = sum(gl) // len(gl)
ele.goal = ans
def genetic_algorithm(bef_group):
# 执行任务并计算适应度
for individual in bef_group:
goal_list = []
for exec_num in range(exec_time):
goal_list.append(cal_adaptability(individual, action_time))
individual.goal = 0
adaptability = sum(goal_list) // len(goal_list)
individual.goal = adaptability
# print("one's goal:", individual.goal)
bef_group.sort(key=lambda x: x.goal, reverse=True)
sample = list(map(lambda x: x.goal, bef_group))
print(sample)
print("均值：",
sum(sample) // len(sample), "最大值：", max(sample), "最小值", min(sample))
print("顶端策略：", end="")
bef_group[0].st.print_sim_table()
# 进化
selector = []
next_group = []
for group_i in range(group_size):
for curr_num in range(max([group_size - group_i - p_size, 1])):
selector.append(group_i)
# print(selector)
while len(next_group) < group_size:
father = random.randint(0, len(selector) - 1)
mother = random.randint(0, len(selector) - 1)
father = selector[father]
mother = selector[mother]
if father == mother:
continue
else:
cut_p = random.randint(1, gene_size - 1)
f_x = bef_group[father].get_sub_x(cut_p)
f_y = bef_group[father].get_sub_y(cut_p)
m_x = bef_group[mother].get_sub_x(cut_p)
m_y = bef_group[mother].get_sub_y(cut_p)
new_bro = f_x + m_y
new_sis = m_x + f_y
# 变异
new_bro_list = list(new_bro)
for gene_i in range(gene_size):
if random.random() < mutation_prob:
print("!", end="")
random_num = random.randint(0, 6)
while random_num == new_bro_list[gene_i]:
random_num = random.randint(0, 6)
new_bro_list[gene_i] = str(random_num)
new_bro = "".join(new_bro_list)
new_sis_list = list(new_sis)
for gene_i in range(gene_size):
if random.random() < mutation_prob:
print("!", end="")
random_num = random.randint(0, 6)
while random_num == new_sis_list[gene_i]:
random_num = random.randint(0, 6)
new_sis_list[gene_i] = str(random_num)
new_sis = "".join(new_sis_list)
next_group.append(Individual(st=Strategy(sim_code=new_bro)))
next_group.append(Individual(st=Strategy(sim_code=new_sis)))
print()
return next_group
kwargs = {
'start': start_date,
'end': end_date,
'initialize': initialize,
'handle_data': handle_data,
'analyze': analyze,
'before_trading_start': before_trading_start,
'after_trading_end': after_trading_end,
'bundle': 'quandl',
'capital_base': config.get('capital_base'),
'algo_name': config.get('name'),
'algo_id': config.get('id'),
'benchmark_symbol': config.get('benchmark_symbol')
}
if args.live_mode == 'True':
if os.path.exists('test.state'):
os.remove('test.state')
print("Running in live mode.")
kwargs['tws_uri'] = 'localhost:7497:1232'
kwargs['live_trading'] = True
else:
kwargs['live_trading'] = False
strategy = Strategy(kwargs)
strategy.run_algorithm()
if args.live_mode != 'True':
input("Press any key to exit")
log = Logger()
live_data = True
do_trade = False
data = DataLoader(ticker, start_time, live_data, do_trade)
model = Model(data)
model.fit()
algorithm = Malgus(data, days, log, model)
action = algorithm.determineInitialAction()
strategy = Strategy(data, action, model)
within_duration = True
while (within_duration):
print ("start action:", action.descr)
action.performAction()
next_action = strategy.chooseNextAction()
action = next_action
within_duration = algorithm.checkStop()
pass
pass
round_cnt += 1
pass
pass
# Show player status
def show_game_status(self):
self.players[0].get_info()
self.players[1].get_info()
pass
# invictus_Gaming = Game()
# invictus_Gaming.start()
invictus_Gaming = Strategy()
invictus_Gaming.cfr_process()
# # Test if equal
# from card import Card
#
# player3 = Player(3, 50)
# player4 = Player(4, 50)
# card1 = []
# card2 = []
# community = []
# card1.append(Card("heart", 3))
# card1.append(Card("heart", 2))
# card2.append(Card("club", 3))
# card2.append(Card("club", 2))
# player3.set_cards(card1)
def on_place_fail(self, reason):
Strategy.on_place_fail(self, reason)
def main():
data = GetData('poloniex', newdata=False)
tickers = ['OMG/BTC'] #tickers = data.tickers()
periods = ['30m'] #periods = ['5m','15m','30m','1h']
maximum_parameters = []
proportion_test = 0.1
graph_results = True
#data.fetch('BTC/USDT') # use if list length error
for tick in tickers:
if tick[-3:] == 'BTC':
data.fetch(tick)
temp_results = []
for period in periods:
'''formats the bitcoin and current coin data to the right period'''
tick_data = data.periodFormatter(tick, period)
startDate = tick_data.index[0]
btc_data = data.periodFormatter('BTC/USDT', period, startDate)
prices = [close for close in tick_data['Close']]
'''formats the raw data to the proportion of data chosen'''
startDate = tick_data.index[int(
(1 - proportion_test) * len(prices))]
endDate = tick_data.index[-1]
btc_prices = btc_data.loc[startDate:endDate]['Close']
tick_prices = tick_data.loc[startDate:endDate]['Close']
for MAlong in [10, 15, 30]:
for x in [2, 3, 4]:
MAshort = int(MAlong / x)
if len(tick_prices) == len(btc_prices):
strategy = Strategy(len(tick_prices))
for count, price in enumerate(tick_prices.values):
strategy.tick(price, btc_prices.values[count])
strategy.movingaverage(MAlong, MAshort, count)
profit, balance = strategy.returnParam()
temp_results.append([
tick, period, tick_prices, strategy, profit,
balance, MAlong, MAshort
])
else:
print('length error')
break
optimumParam = None
for result in temp_results:
if optimumParam == None:
optimumParam = result
optimum = result
elif result[5] > optimumParam[5]:
optimumParam = result
else:
pass
print(optimumParam[0], optimumParam[1], optimumParam[4],
optimumParam[5], optimumParam[6], optimumParam[7])
maximum_parameters.append(optimumParam)
for param in maximum_parameters:
plot = Graphics(param[2], param[3].MAlong, param[3].MAshort,
param[3].buylist, param[3].selllist,
param[3].balanceList)
plot.MA_plot()
def strategy(emotion_multiplier):
return Strategy(
lambda id: BasicEmotionPrisoner(id, emotion_multiplier),
BasicEmotionPrisoner.prisoner_type)
def setUp(self):
self.board = Board()
self.strategy = Strategy(self.board, 'X')
#print data.head()
"""
Main Entry point
"""
if __name__ == '__main__':
dt = DataConstructor()
dt.BuildData('002215')
data = dt.GetData()
CloseOrder = []
st = Strategy(data,CloseOrder)
plotter = Plotter(data)
st.run1()
plotter.plot1(st.getoo())
#data = pd.read_csv('000001.csv')
"""
#init the margin column
#data['margin']=np.zeros(len(data))
#create indicator
ind = Indicator(data)
ind.genIndicator()
#create the strategy
# 是否交易的日期
if not calendar.trade_day():
none_trade_day()
continue
elif not calendar.trade_time(): #交易日非交易时间段
none_trade_time()
continue
else: #进入交易时间 calendar.trade_day() & calendar.trade_time()
trade_time()
#time.sleep(.5)
if __name__ == "__main__":
#winsound.PlaySound('./wav/good afternoon CN.wav',winsound.SND_ASYNC)
#time.sleep(3)
args = sys.argv
if len(args) == 5:
strategy = Strategy(args[1], args[2], args[3], args[4])
else:
strategy = Strategy("QUERY_2_DAYS_HARD", 20, 5, 10)
time.sleep(.5)
trader = DFCF_Trader()
calendar = TradeCalendar()
quotation = PriceQuotation()
try:
run()
except KeyboardInterrupt:
#关闭打开的线程
trader.kill = 1
quotation.kill = 1
print '\n\nCtrl-C Entered'
class DukascopyEngine:
def connect(self, instruments, period, strategyClass, strategyParams=None, getStat=False):
self.name = 'Dukascopy'
self.instruments = instruments
self.period = period
self.getStat = getStat
self.strategy = strategyClass(self)
self.strategyParams = strategyParams
self.strategyClass = strategyClass
self.slippage = 0
self.start()
def __init__(self):
"""for use getHistory without runing strategy"""
self.strategy = Strategy(self)
def start(self):
context = zmq.Context()
socket = context.socket(zmq.SUB)
socket.connect('tcp://127.0.0.1:43001')
for instrument in self.instruments:
socket.setsockopt(zmq.SUBSCRIBE, instrument)
self.strategy.onStart()
###main bars loop#######################################
while True:
filter = socket.recv()
bar = socket.recv()
bar = bar.split(' ')
if self.period != (bar[0] + " " + bar[1]):
continue
bar[2] = datetime.utcfromtimestamp(float(bar[2]) / 1e3)
bar = np.array(bar)
bar = bar[2:]
bar[1:11] = bar[1:11].astype(np.float32, copy=False)
bar[1:11] = np.around(bar[1:11].astype(np.double),5)
self.strategy.onBar(bar)
###main bars loop#######################################
self.strategy.onStop()
def sendOrder(self, order, bar=None):
context = zmq.Context()
socket = context.socket(zmq.REQ)
socket.connect("tcp://127.0.0.1:43002")
type = ""
if order.market == True:
if order.orderType == 1:
type = "BUY"
else:
type = "SELL"
else:
if order.orderType == 1:
type = "BUYLIMIT"
else:
type = "SELLLIMIT"
order = ['sendOrder', self.strategyClass.name, order.instrument, type, str(order.lot), str(order.price),
str(self.slippage), str(order.stop), str(order.target), str(order.timeStopTime)]
command = '--'.join(order)
socket.send(command)
message = socket.recv()
return message
def closeOrder(self, order, bar=None):
context = zmq.Context()
socket = context.socket(zmq.REQ)
socket.connect("tcp://127.0.0.1:43002")
type = ""
if order.market == True:
if order.orderType == 1:
type = "BUY"
else:
type = "SELL"
else:
if order.orderType == 1:
type = "BUYLIMIT"
else:
type = "SELLLIMIT"
order = ['closeOrder', self.strategy.name, order.instrument, type, str(order.lot), str(order.price),
str(self.slippage), str(order.stop), str(order.target), str(order.timeStopTime)]
command = '--'.join(order)
socket.send(command)
message = socket.recv()
return message
def closePosition(self, position, bar=None):
self.closeOrder(position.order, bar)
def getOrders(self):
context = zmq.Context()
socket = context.socket(zmq.REQ)
socket.connect("tcp://127.0.0.1:43002")
orders = []
for instrument in self.instruments:
command = ['getOrders', self.strategy.name, instrument]
command = '--'.join(command)
socket.send(command)
message = socket.recv()
if message != '':
orderStrings = message.split('-+-')
for orderString in orderStrings:
orderString = orderString.split('--')
market = True
orderType = 1
if orderString[2] == "SELL":
orderType = -1
if orderString[2] == "BUYLIMIT":
market = False
if orderString[2] == "SELLLIMIT":
orderType = -1
market = False
orders.append(
Order(instrument=orderString[1], orderType=orderType, market=market, lot=orderString[3],
price=orderString[4], stop=orderString[5],
target=orderString[6], timeStopTime=orderString[7], openTime=orderString[8]))
return orders
def getPositions(self):
context = zmq.Context()
socket = context.socket(zmq.REQ)
socket.connect("tcp://127.0.0.1:43002")
positions = []
for instrument in self.instruments:
command = ['getPositions', self.strategy.name, instrument]
command = '--'.join(command)
socket.send(command)
message = socket.recv()
if message != '':
positionStrings = message.split('-+-')
for positionString in positionStrings:
positionString = positionString.split('--')
market = True
orderType = 1
if positionString[2] == "SELL":
orderType = -1
if positionString[2] == "BUYLIMIT":
market = False
if positionString[2] == "SELLLIMIT":
orderType = -1
market = False
timeStopTime = datetime.utcfromtimestamp(float(positionString[7]) / 1e3)
orderOpenTime = datetime.utcfromtimestamp(float(positionString[8]) / 1e3)
positionOpenTime = datetime.utcfromtimestamp(float(positionString[9]) / 1e3)
positions.append(Position(
Order(instrument=positionString[1], orderType=orderType, market=market, lot=positionString[3],
price=positionString[4], stop=positionString[5],
target=positionString[6], timeStopTime=timeStopTime, openTime=orderOpenTime),
openTime=positionOpenTime))
return positions
def getHistoryBars(self, instrument, barsBefore, shift, barsAfter=0, period='ONE_MIN', trimInstrument = False, filterWeekends = True):
context = zmq.Context()
socket = context.socket(zmq.REQ)
socket.connect("tcp://127.0.0.1:43002")
command = ['getHistory', self.strategy.name, instrument, period, str(barsBefore), str(shift),
str(barsAfter), str(filterWeekends)] # command, strategyName, intrument, period, barsBefore, shift, barsAfter
command = '--'.join(command)
socket.send(command)
message = socket.recv()
bars = []
if message != '':
barsStrings = message.split('-+-')
for barStrings in barsStrings:
bar = barStrings.split('--')
bar[1] = datetime.utcfromtimestamp(float(bar[1]) / 1e3)
bar = bar[1:]
bar = np.array(bar)
bar[1:11] = bar[1:11].astype(np.float32, copy=False)
bar[1:11] = np.around(bar[1:11].astype(np.double),5)
if trimInstrument == True:
bar = bar[:11]
bars.append(bar)
bars = np.array(bars)
return bars
def getHistoryFromDateUntilNow(self, instrument, period, dateFrom, trimInstrument = False):
context = zmq.Context()
socket = context.socket(zmq.REQ)
socket.connect("tcp://127.0.0.1:43002")
command = ['getHistoryFromDateUntilNow', self.strategy.name, instrument, period, str(dateFrom)] # command, strategyName, intrument, period, barsBefore, shift, barsAfter
command = '--'.join(command)
socket.send(command)
message = socket.recv()
print message
bars = []
if message != '':
barsStrings = message.split('-+-')
for barStrings in barsStrings:
bar = barStrings.split('--')
bar[1] = datetime.utcfromtimestamp(float(bar[1]) / 1e3)
bar = bar[1:]
bar = np.array(bar)
bar[1:11] = bar[1:11].astype(np.float32, copy=False)
bar[1:11] = np.around(bar[1:11].astype(np.double),5)
if trimInstrument == True:
bar = bar[:11]
bars.append(bar)
bars = np.array(bars)
return bars
def getHistoryFromDateToDate(self, instrument, period, dateFrom, dateTo, trimInstrument = False):
context = zmq.Context()
socket = context.socket(zmq.REQ)
socket.connect("tcp://127.0.0.1:43002")
command = ['getHistoryFromDateToDate', self.strategy.name, instrument, period, str(dateFrom), str(dateTo)] # command, strategyName, intrument, period, barsBefore, shift, barsAfter
command = '--'.join(command)
socket.send(command)
message = socket.recv()
bars = []
if message != '':
if message.find('JFException') != -1:
return message
barsStrings = message.split('-+-')
for barStrings in barsStrings:
bar = barStrings.split('--')
bar[1] = datetime.utcfromtimestamp(float(bar[1]) / 1e3)
bar = bar[1:]
bar = np.array(bar)
bar[1:11] = bar[1:11].astype(np.float32, copy=False)
bar[1:11] = np.around(bar[1:11].astype(np.double),5)
if trimInstrument == True:
bar = bar[:11]
bars.append(bar)
bars = np.array(bars)
return bars
def __init__(self, bars, balance_start, bankruptcy_at, multiplier, transaction_costs, slippage, timeperiod):
Strategy.__init__(self, bars, balance_start, bankruptcy_at, multiplier, transaction_costs, slippage)
pdta.SETTINGS.join = False
self.indicator = pdta.MA(self.bars_pd, timeperiod)
transitions_player1.extend(transitions_player_1)
transitions_player2.extend(transitions_player_2)
return transitions_player1, transitions_player2
def constant_function(x):
def fn():
return x
return fn
if __name__ == "__main__":
cnn = CNN()
stg = Strategy(cnn)
megaman = Agent(stg) # player 1
megaman.get_exploration_factor = constant_function(EXPLORATION)
megaman.train()
performance = []
print("Training ... ")
for t in itertools.count():
megaman.train()
# p1, p2 = play_many([megaman, "negamax"], num_games=GAMES_PER_EPISODE)
p1, p2 = play_many(["negamax", megaman], num_games=GAMES_PER_EPISODE)
transitions = Transition(*zip(*p2))
num_wins = transitions.reward.count(1)
win_ratio = num_wins / GAMES_PER_EPISODE
print(f"WR: {win_ratio:>6.2%}")
performance.append(win_ratio)
if os.path.isfile(DATASET_JSON):
with open(DATASET_JSON) as dataset_json:
items = json.load(dataset_json)["0"]
else:
items = numpy.zeros(DATASET_SIZE, dtype=int)
items[:int(len(items) * SELECTIVITY)] = 1
numpy.random.shuffle(items)
numpy.random.shuffle(items)
dataset = dict()
dataset[0] = list(items)
with open(DATASET_JSON, "w") as dataset_json:
json.dump(dataset, dataset_json)
enumerated = dict()
for (index, item) in enumerate(items):
enumerated[index] = item
test = dict()
for i in range(TEST_PHASES):
its = numpy.zeros(TEST_PHASE_SIZE, dtype=int)
its[:TEST_PHASE_SIZE / 2] = 1
numpy.random.shuffle(its)
test[i] = its
crowd = Crowd(NUM_USERS, ERROR_RATE_YES, ERROR_RATE_NO, test)
avg_er_yes = crowd.avg_er_yes
avg_er_no = crowd.avg_er_no
strategy = Strategy(M, M)
unc_opt_cost = UncOptCost()
unc_opt_cost.unc_opt_cost(enumerated, K, SELECTIVITY, avg_er_yes, strategy,
crowd)
def __init__(self, n=DEFAULT_N):
'''
Constructor
'''
Strategy.__init__(self)
self._n = n
def __init__(self):
Strategy.__init__(self)
self.target_vps_count = int(plebnet_settings.get_instance().strategy_vps_count())
def run_strategy(name, path):
strategy = Strategy(name, path)
strategy.run()
def __init__(self):
"""for use getHistory without runing strategy"""
self.strategy = Strategy(self)
def __init__(self,config): Strategy.__init__(self,config) self.placer = Placer(config) self.picker = Picker(config)
s_result['pct_simple_profit'] = self.abs_profit / self.max_open
s_result['pct_compound_profit'] = self.pct_compound_profit
s_result['annual_pct_simple_profit'] = (1+s_result['pct_simple_profit'])**self.years-1
s_result['annual_pct_compound_profit'] = (1+s_result['pct_compound_profit'])**self.years-1
s_result['volatility'] = np.std(self.profit_trades) * (1/self.years)**(1/2) # Annual volatility
s_result['sharpe'] = s_result['annual_pct_simple_profit'] / s_result['volatility']
print s_result['sharpe']
return s_result
def save_result(self):
writer = pd.ExcelWriter("test_simulation.xlsx")
df_result.to_excel(writer,"simulation")
#===============================================================================
# FUNCTIONS
#===============================================================================
#===============================================================================
# MAIN
#===============================================================================
if __name__=='__main__':
strategy = Strategy()
strategy.post_open_conditions(ndowns = 4)
strategy.post_close_conditions(nups = 1)
sim = Simulation("SPY", from_date='20050101', to_date='20120612')
sim.get_prices_yahoo()
sim.apply_strategy(strategy)
s_result = sim.get_result()
print s_result
# Timedelta -> Str
def time_format(t):
return str(datetime.timedelta(seconds=int(t)))
# Event -> Strategy
lo = lambda event: Strategy([
rules.LayTheOutsider(liability=100,
initial_price_from=3.75,
price_from=4,
price_to=13,
time_from=-10,
time_to=70),
rules.Green([
Condition(
op.eq, S.back_price(S.home),
S.maximum(S.back_price(S.away), S.back_price(S.home),
S.back_price(S.the_draw))),
Condition(
op.eq, S.back_price(S.away),
S.minimum(S.back_price(S.away), S.back_price(S.home),
S.back_price(S.the_draw)))
])
], event)
one_x = lambda event: Strategy([
rules.OneX(liability=100,
margin=.07,
away_initial_price_from=3.5,
time_from=-10,
time_to=70,
if self.portfolio_value is None:
self._calculate_portfolio_value()
return self.portfolio_value
def _calculate_portfolio_value(self):
data = (self.portfolio.allocations.
loc[:,
self.portfolio.allocations.columns != Portfolio.CASH].mul(
self.stock_data.adj_close,
fill_value=None).ffill().sum(axis="columns").add(
self.portfolio.allocations[Portfolio.CASH],
fill_value=None).ffill())
self.portfolio_value = pd.DataFrame(data=data,
columns=[self.CLOSING_VALUE])
if __name__ == "__main__":
symbols = ["SPY", "AMZN"]
start = "2016-11-01"
end = "2017-11-01"
dates = pd.date_range(start=start, end=end)
stock_data = StockData(symbols, dates=dates)
strategy = Strategy()
portfolio = Portfolio(symbols=symbols, stock_data=stock_data, dates=dates)
portfolio.optimize(strategy=strategy, stock_data=stock_data)
portfolio_analyzer = PortfolioAnalyzer(portfolio=portfolio,
stock_data=stock_data)
def setUp(self):
self.problem = Problem()
self.strategy = Strategy()
def load_strategy(self): ''' called by simulator ''' self.strategy = Strategy(self, self.instrument, self.start_date, self.end_date)
def on_place(self, oid, side, price, size, otype):
Strategy.on_place(self, oid, side, price, size, otype)
from tradingBot import TradingBot
from portfolio import Portfolio
from database import Database
from priceReceiver import Receiver
from tradeUpdates import TradeUpdates
config = configparser.ConfigParser()
config.read('config.ini')
account_id = 'ua'
db_url = os.environ['DATABASE_URL']
db_conn = Database.create_connection(db_url)
move_av = Strategy(
db_conn, 'moving_average',
'limit', window_len = 5,
lookback_len = 7, buy_threshold = 0.01,
profit_margin = 0.005, stop_threshold = 0.005)
account = Portfolio(account_id)
tradeReceiver = TradeUpdates(
"wss://paper-api.alpaca.markets/stream",
db_url, account_id)
dataReceiver = Receiver(
"wss://data.alpaca.markets/stream", db_url)
traderBot = TradingBot(move_av, account, period = 60)
tradeReceiver.start()
dataReceiver.start()
# NDOWNS-NUPS
#===========================================================================
# strategy = Strategy(type='ndowns-nups')
# strategy.post_open_conditions(ndowns = 4)
# strategy.post_close_conditions(nups = 1)
# sim = Simulation("SPY", from_date='20000101', to_date='20140612')
# sim.apply_strategy(strategy)
# s_result = sim.get_result()
# print 'ndowns-nups: '
# print s_result
#===========================================================================
# PCTDOWN-NUPS - INTERDAY WITH YAHOO PRICES
#===========================================================================
strategy = Strategy(type='pctdown-nups', pctdown=5.0, nups=1)
sim = Simulation("SPY", from_date='20000101', to_date='20140612')
sim.get_prices_yahoo()
sim.apply_strategy(strategy)
s_result = sim.get_result()
sim.save_result()
print 'pctdown-nups: '
print s_result
#===========================================================================
# PCTDOWN-NUPS - INTRADAY WITH IB PRICES
#===========================================================================
strategy = Strategy(type='pctdown-nups', pctdown=5.0, nups=1)
sim = Simulation("AAPL", from_date='20000101', to_date='20140612')
sim.get_prices_IB()
sim.apply_strategy(strategy)
def __init__(self, color):
Strategy.__init__(self, color)
# -*- coding: utf-8 -*-
from strategy import Strategy
import settings
import logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger("Sample")
def mylogic(ticker, ohlcv, position, balance, strategy):
pass
strategy = Strategy(mylogic)
strategy.settings.timeframe = '1m'
strategy.settings.interval = 10
strategy.settings.partial_ohlcv = True
strategy.testnet.use = True
strategy.testnet.apiKey = settings.testnet_apiKey
strategy.testnet.secret = settings.testnet_secret
strategy.start()
parser.add_argument('--config', type=argparse.FileType('r'))
parser.add_argument('--bbos')
parser.add_argument('--trds')
args = parser.parse_args()
config = json.load(args.config)
log = Logger('backtest')
log.operation({'config': config})
watch_threshold = config['watch_threshold']
watch_duration = config['watch_duration']
slowdown_threshold = config['slowdown_threshold']
slowdown_duration = config['slowdown_duration']
strategy = Strategy(watch_threshold, watch_duration,
slowdown_threshold, slowdown_duration)
with io.TextIOWrapper(gzip.open(args.bbos, 'r')) as fh:
fh.readline() # skip header
bbos = collections.deque((process_bbo(line) for line in fh))
with io.TextIOWrapper(gzip.open(args.trds, 'r')) as fh:
fh.readline() # skip header
trds = collections.deque((process_trd(line) for line in fh))
current_trd = {'px': np.nan}
current_bbo = {'bid_px': np.nan, 'ask_px': np.nan}
end_of_time = np.datetime64('3000-01-01T00:00:00.000000')
while bbos or trds:
def _generate_strategies(self):
"""Generates a pool of strategies to play."""
size = self._config.get("number_strategies")
return [Strategy(self._config) for _ in range(size)]
