def load_symbol(self, symbol):
logging.info("loading symbol %s", symbol)
self.b3_dealer.historical_symbol_ticker_candle(
symbol, datetime(year=2021, day=4, month=1),
datetime(year=2021, day=20, month=5))
# data = pd.read_csv('../data/petr4.sa')
data = self.b3_dealer.historical_data[
self.b3_dealer.historical_data.symbol ==
self.b3_dealer.get_symbol_ticker(symbol)]
if len(data):
self.scene[0].set_data(data)
self.ta_data.set_data(data, self.scene[0].timeline)
# ta
self.ta = TA(data)
self.curves.append(CurveModel(self))
self.curves[0].set_from_data(self.ta.ema(3),
self.scene[0].timeline)
self.curves.append(CurveModel(self))
self.curves[1].set_from_data(self.ta.ema(10),
self.scene[0].timeline)
self.curves[1].color = (0.0, 0.0, 1.0, 1.0)
# focus camera
last_x = self.scene[0].timeline.index_pos(len(data))
last_y = data.iloc[-1]["open"]
width = self.scene[0].timeline.index_pos(14) # 7 days radius
self.camera = OrthographicCamera((last_x, last_y), width, self.wnd)
class TAData:
curves: [CurveModel]
resistance_lines_data: [[]]
resistance_lines: [CurveModel]
resistance_line_count: int
ta: TA
def __init__(self, wcg):
self.wcg = wcg
self.resistance_lines_data = []
self.resistance_lines = []
def set_data(self, data, timeline: TimeLine):
self.ta = TA(data)
support_lines_data = self.ta.resistance_lines('s')
self.resistance_lines_data = self.ta.resistance_lines('r')
self.resistance_line_count = len(self.resistance_lines_data[0])
self.resistance_lines_data[0].extend(support_lines_data[0])
self.resistance_lines_data[1].extend(support_lines_data[1])
def horizontal_line(values, ids, color):
model = CurveModel(self.wcg)
model.color = color
model.set_horizontal_line(
np.array(values).mean(), 1000, timeline.index_pos(min(ids)))
return model
for i in range(len(self.resistance_lines_data[0])):
self.resistance_lines.append(
horizontal_line(self.resistance_lines_data[0][i],
self.resistance_lines_data[1][i],
(1, 0, 0, 1)))
def draw_closest_resistance_line(self, c: OrthographicCamera, price: float,
current_index: int):
if not len(self.resistance_lines_data):
return
r = get_closest_resistance(self.resistance_lines_data, price,
current_index)
if r[0] >= price and r[1] >= 0:
self.resistance_lines[r[1]].draw(c)
def draw_closest_support_line(self, c: OrthographicCamera, price: float,
current_index: int):
if not len(self.resistance_lines_data):
return
r = get_closest_support(self.resistance_lines_data, price,
current_index)
if r[0] <= price and r[1] >= 0:
self.resistance_lines[r[1]].draw(c)
def historical_candle_series(self, symbols, start: datetime, end,
interval):
candles = {}
symbol_list = symbols
if type(symbols) is str:
symbol_list = [symbols]
self.download_history(symbol_list, start, end, interval)
for symbol in symbol_list:
candle_data = self.historical_data[self.historical_data.symbol ==
self.get_symbol_ticker(symbol)]
candle_data = candle_data[candle_data.interval == interval]
candle_data = candle_data[candle_data.date >= start]
candle_data = candle_data[candle_data.date <= end]
prices = []
for _, candle in candle_data.iterrows():
prices.append(
Price(date=candle['date'],
symbol=candle['symbol'],
current=float(candle['open']),
open=float(candle['open']),
close=float(candle['close']),
low=float(candle['low']),
high=float(candle['high']),
volume=float(candle['volume']),
interval=interval))
candles[symbol] = {"prices": prices, "ta": TA(candle_data)}
return candles
def historical_candle_series(self, symbols, start: datetime, end=None, interval: str = '1d'):
if end is None:
end = datetime.today()
if end.isoweekday() > 5:
end -= timedelta(days=end.isoweekday() - 5)
end = end.replace(hour=0, minute=0, second=0, microsecond=0)
symbol_list = symbols
if type(symbols) is str:
symbol_list = [symbols]
self.download_history(symbol_list, start, end, interval)
candles = {}
for symbol in symbol_list:
candle_data = self.historical_data[self.historical_data.symbol == self.get_symbol_ticker(symbol)]
candle_data = candle_data[candle_data.date >= start]
candle_data = candle_data[candle_data.date <= end]
prices = []
for _, candle in candle_data.iterrows():
prices.append(Price(date=candle['date'],
symbol=candle['symbol'],
current=float(candle['open']),
open=float(candle['open']),
close=float(candle['close']),
low=float(candle['low']),
high=float(candle['high']),
volume=float(candle['volume']),
interval=interval))
candles[symbol] = {
"prices": prices,
"ta": TA(candle_data)
}
return candles
def backtrace(self, dealer: Dealer, start: datetime, end=None):
asset_symbols = [a[0] for a in self.assets]
dealer.historical_symbol_ticker_candle(asset_symbols, start, end)
total_value = self.balance()
results = {}
for asset in self.assets:
ta = TA(dealer.historical_data[dealer.historical_data.symbol ==
dealer.get_symbol_ticker(asset[0])])
pct_change = ta.single_pct_change()
final_value = asset[1] + asset[1] * pct_change / 100.0
results[asset[0]] = {
"change": (pct_change, final_value),
"max": (ta.max_in_range()[0], ta.max_pct_in_range()[0],
ta.max_in_range()[1])
}
total_value += final_value - asset[1]
results['total'] = (total_value, (total_value - self.balance()) /
self.balance() * 100.0)
return results
def set_data(self, data, timeline: TimeLine):
self.ta = TA(data)
support_lines_data = self.ta.resistance_lines('s')
self.resistance_lines_data = self.ta.resistance_lines('r')
self.resistance_line_count = len(self.resistance_lines_data[0])
self.resistance_lines_data[0].extend(support_lines_data[0])
self.resistance_lines_data[1].extend(support_lines_data[1])
def horizontal_line(values, ids, color):
model = CurveModel(self.wcg)
model.color = color
model.set_horizontal_line(
np.array(values).mean(), 1000, timeline.index_pos(min(ids)))
return model
for i in range(len(self.resistance_lines_data[0])):
self.resistance_lines.append(
horizontal_line(self.resistance_lines_data[0][i],
self.resistance_lines_data[1][i],
(1, 0, 0, 1)))
def __init__(self, **kwargs):
super().__init__(**kwargs)
# historical data
# self.data = Ticker('petr4.sa').history(period="ytd").reset_index(drop=False)
self.data = pd.read_csv('../data/petr4.sa')
# strategy specifics
self.ta = TA(self.data)
self.support_lines_data = self.ta.resistance_lines('s')
self.resistance_lines_data = self.ta.resistance_lines('r')
print(self.ta.candle_directions())
print(self.ta.reversals())
# simulation
self.tick_count = len(self.data)
self.current_tick = 0
# scene
self.scene.append(CandleStickChart(self))
self.scene[0].set_data(self.data)
# focus camera
last_x = self.scene[0].timeline.index_pos(len(self.data))
last_y = self.data.iloc[-1]["open"]
width = self.scene[0].timeline.index_pos(14) # 7 days radius
self.camera = OrthographicCamera((last_x, last_y), width, self.wnd)
# resistance lines
self.resistance_lines = []
for i in range(len(self.resistance_lines_data[0])):
self.resistance_lines.append(
ResistanceLine(self, self.resistance_lines_data[0][i],
self.resistance_lines_data[1][i],
self.scene[0].timeline, (1, 0, 0, 1.0)))
# support lines
self.support_lines = []
for i in range(len(self.support_lines_data[0])):
self.support_lines.append(
ResistanceLine(self, self.support_lines_data[0][i],
self.support_lines_data[1][i],
self.scene[0].timeline, (0, 1, 0, 1.0)))
class CustomStrategy(App, Strategy):
def __init__(self, **kwargs):
super().__init__(**kwargs)
# historical data
# self.data = Ticker('petr4.sa').history(period="ytd").reset_index(drop=False)
self.data = pd.read_csv('../data/petr4.sa')
# strategy specifics
self.ta = TA(self.data)
self.support_lines_data = self.ta.resistance_lines('s')
self.resistance_lines_data = self.ta.resistance_lines('r')
print(self.ta.candle_directions())
print(self.ta.reversals())
# simulation
self.tick_count = len(self.data)
self.current_tick = 0
# scene
self.scene.append(CandleStickChart(self))
self.scene[0].set_data(self.data)
# focus camera
last_x = self.scene[0].timeline.index_pos(len(self.data))
last_y = self.data.iloc[-1]["open"]
width = self.scene[0].timeline.index_pos(14) # 7 days radius
self.camera = OrthographicCamera((last_x, last_y), width, self.wnd)
# resistance lines
self.resistance_lines = []
for i in range(len(self.resistance_lines_data[0])):
self.resistance_lines.append(
ResistanceLine(self, self.resistance_lines_data[0][i],
self.resistance_lines_data[1][i],
self.scene[0].timeline, (1, 0, 0, 1.0)))
# support lines
self.support_lines = []
for i in range(len(self.support_lines_data[0])):
self.support_lines.append(
ResistanceLine(self, self.support_lines_data[0][i],
self.support_lines_data[1][i],
self.scene[0].timeline, (0, 1, 0, 1.0)))
# render
def render_callback(self, time: float):
for o in self.scene:
o.draw(self.camera)
for o in self.scene:
o.draw_gui(self.camera)
# self.scene[0].render(self.camera)
# self.scene[0].render_gui(self.camera)
# for rl in self.resistance_lines:
# rl.draw(self.scene[0].camera)
# for sl in self.support_lines:
# sl.draw(self.scene[0].camera)
# self.support.draw(self.scene[0].camera)
# self.resistance.draw(self.scene[0].camera)
# move in the timeline
mouse_price = self.scene[0].measures.current_pointer[1]
mouse_tick = self.scene[0].timeline.pos_index(
self.scene[0].measures.current_pointer[0])
old_tick = self.current_tick
self.current_tick = int(time) % self.tick_count
if old_tick != self.current_tick:
self.run()
# mouse_price = self.data.iloc[self.current_tick]['close']
# mouse_tick = self.current_tick
# self.scene[0].candlestick_model.upper_cut = self.current_tick
current_support = get_closest_support(self.support_lines_data,
mouse_price, mouse_tick - 1)
if current_support[0] <= mouse_price and current_support[1] >= 0:
self.support_lines[current_support[1]].draw(self.camera)
current_resistance = get_closest_resistance(self.resistance_lines_data,
mouse_price,
mouse_tick - 1)
if current_resistance[0] >= mouse_price and current_resistance[1] >= 0:
self.resistance_lines[current_resistance[1]].draw(self.camera)
# run strategy
def run(self):
pass
class MainApp(App):
# dealers
cripto_dealer: BinanceExchange
b3_dealer: YQBroker
# wallets
cripto_wallet: Wallet
b3_wallet: Wallet
# windows
my_wallet_window: MyWalletWindow
strategy_backtrace_window: StrategyBacktraceWindow
# gui
symbol_list = fund.get_symbol_list("../tests/raw_fund_html", False)
input_text = ""
def __init__(self, **kwargs):
super().__init__(**kwargs)
# scene
self.ta_data = TAData(self)
self.scene.append(CandleStickChart(self))
self.ta = None
self.curves = []
self.b3_dealer = YQBroker()
self.b3_wallet = Wallet()
self.b3_wallet.load_cache('../data/transactions.csv')
self.b3_wallet.log()
self.my_wallet_window = MyWalletWindow(self.b3_wallet)
self.strategy_backtrace_window = StrategyBacktraceWindow()
# render
def render_callback(self, time: float):
self.my_wallet_window.draw()
self.strategy_backtrace_window.draw()
self.menu_bar()
for o in self.scene:
o.draw(self.camera)
for o in self.scene:
o.draw_gui(self.camera)
for c in self.curves:
c.draw(self.camera)
mouse_price = self.scene[0].measures.current_pointer[1]
mouse_tick = self.scene[0].timeline.pos_index(
self.scene[0].measures.current_pointer[0])
self.ta_data.draw_closest_support_line(self.camera, mouse_price,
mouse_tick)
self.ta_data.draw_closest_resistance_line(self.camera, mouse_price,
mouse_tick)
def cleanup(self):
del self.my_wallet_window
self.b3_wallet.save_cache('../data/transactions.csv')
del self.b3_wallet
def menu_bar(self):
if imgui.begin_main_menu_bar():
if imgui.begin_menu("File", True):
clicked_quit, selected_quit = imgui.menu_item(
"Quit", 'Cmd+Q', False, True)
if clicked_quit:
self.cleanup()
exit(0)
imgui.end_menu()
changed, value = imgui.input_text("", self.input_text, 30)
if changed:
imgui.set_next_window_position(imgui.get_item_rect_min().x,
imgui.get_item_rect_max().y)
imgui.set_next_window_size(imgui.get_item_rect_size().x, 0)
if imgui.begin(
"##popup", False, imgui.WINDOW_NO_TITLE_BAR
| imgui.WINDOW_NO_MOVE | imgui.WINDOW_NO_RESIZE):
for index, row in self.symbol_list.iterrows():
if value.upper() in row[0]:
_, _ = imgui.selectable(row[0] + " - " + row[2])
if imgui.is_item_clicked():
self.input_text = row[0]
self.load_symbol(str(row[0]).lower())
imgui.end()
imgui.end_main_menu_bar()
def load_symbol(self, symbol):
logging.info("loading symbol %s", symbol)
self.b3_dealer.historical_symbol_ticker_candle(
symbol, datetime(year=2021, day=4, month=1),
datetime(year=2021, day=20, month=5))
# data = pd.read_csv('../data/petr4.sa')
data = self.b3_dealer.historical_data[
self.b3_dealer.historical_data.symbol ==
self.b3_dealer.get_symbol_ticker(symbol)]
if len(data):
self.scene[0].set_data(data)
self.ta_data.set_data(data, self.scene[0].timeline)
# ta
self.ta = TA(data)
self.curves.append(CurveModel(self))
self.curves[0].set_from_data(self.ta.ema(3),
self.scene[0].timeline)
self.curves.append(CurveModel(self))
self.curves[1].set_from_data(self.ta.ema(10),
self.scene[0].timeline)
self.curves[1].color = (0.0, 0.0, 1.0, 1.0)
# focus camera
last_x = self.scene[0].timeline.index_pos(len(data))
last_y = data.iloc[-1]["open"]
width = self.scene[0].timeline.index_pos(14) # 7 days radius
self.camera = OrthographicCamera((last_x, last_y), width, self.wnd)
parser = argparse.ArgumentParser(description="")
# retrieve symbol list
# symbol_list = fund.get_symbol_list("../tests/raw_fund_html", False).sample(1)
symbol_list = ["PETR4"]
# create ticker list
tickers = list()
for name in symbol_list:
logging.info("Downloading history of %s", name)
tickers.append(Ticker(name + ".SA"))
# retrieve history data
tas = []
for ticker in tickers:
# check cache first
cache_file = "../data/" + ticker.symbols[0]
if os.path.isfile(cache_file):
tas.append(TA(pd.read_csv(cache_file)))
else:
data = ticker.history()
data.to_csv(cache_file)
tas.append(TA(data))
class Data:
resistance_lines = None
support_lines = None
for ta in tas:
data = Data()
data.support_lines = ta.resistance_lines("s")
data.resistance_lines = ta.resistance_lines("r")
ta.run(run, data)
plot_ta(ta)