def sync_account_info(self, force=True):
u = self.times.get('a')
if not force and u:
t = now_minus(seconds=self.sync_interval)
if u > t:
return False
self.gdax.sync_accounts()
self.times['a'] = now()
def export_chart():
d = GdaxChartData(
g,
'ETH-USD',
now_minus(days=1),
now(),
granularity=60 * 5,
)
d.df.to_csv(chart_path, index=False)
def sync_ticker_info(self, force=True):
u = self.times.get('t')
if not force and u:
t = now_minus(seconds=self.sync_interval)
if u > t:
return False
t = self.gdax.get_ticker(self.name)
self._price = float(t['price'])
self._volume24hr = float(t['volume'])
self.times['t'] = now()
def sync_24hr_stats(self, force=True):
u = self.times.get('s')
if not force and u:
t = now_minus(seconds=self.sync_interval)
if u > t:
return False
s = self.gdax.get_24hr_stats(self.name)
self._volume24hr = float(s['volume'])
self._high24hr = float(s['high'])
self._low24hr = float(s['low'])
self.times['s'] = now()
def get_sample_chart(size=31, price_factor=1.25, minute_interval=5):
data = list()
start = now_minus(hours=10)
price = 1
for i in range(1, size + 1):
data.append((start, price))
start += DateOffset(minutes=minute_interval)
price *= price_factor
return DataFrame(data=data,
columns=['time', 'price'],
index=range(len(data)))
def generate_candles(product,
gdax=None,
out_path=None,
start=None,
end=None,
granularity=60 * 60 * 24):
"""
Generates a .csv file containing open, high, low, close & volume
information for a given product.
:param product:
:param gdax:
:param out_path:
:param start:
:param end:
:param granularity:
:return: (GdaxChartData, str)
Returns the generated ChartData object along with the out_path.
"""
if gdax is None:
gdax = Gdax()
if out_path is None:
import os
from stocklook.config import config
d = config['DATA_DIRECTORY']
c = product.split('-')[0]
n = '{}_candles.csv'.format(c)
out_path = os.path.join(d, n)
if start is None:
from stocklook.utils.timetools import now_minus
start = now_minus(weeks=4)
if end is None:
from stocklook.utils.timetools import now
end = now()
data = GdaxChartData(gdax, product, start, end, granularity)
data.df.to_csv(out_path, index=False)
get_buypoint(data)
return data, out_path
def get_chart(self, time_frame='5M'):
"""
Access to GdaxChartData objects that are automatically created,
cached, and/or refreshed on an interval.
:param time_frame (str, default '5M')
The timeframe interval of chart data to get.
5M: 5 minutes
15M: 15 minutes
1H: 1 hour
4H: 4 hours
1D: daily
:return: (stocklook.crypto.gdax.chartdata.GdaxChartData)
"""
assert time_frame in self.TIME_FRAMES
key = 'chart_data_{}'.format(time_frame)
chart = self._charts.get(key, None)
granularity, hours_back, seconds = self.TIMEFRAME_MAP[time_frame]
timed_out = timeout_check(key, t_data=self._t_data, seconds=seconds)
start = now_minus(hours=hours_back)
end = now_plus(days=1)
if chart is None:
from stocklook.crypto.gdax.chartdata import GdaxChartData
chart = GdaxChartData(self.gdax,
self.product_id,
start,
end,
granularity=granularity)
chart.get_candles()
self._charts[key] = chart
elif timed_out:
chart.start = start
chart.end = end
chart.get_candles()
return chart
import pytest, os
from stocklook.crypto.gdax.chartdata import GdaxChartData
from stocklook.crypto.gdax.api import Gdax
from stocklook.utils.timetools import now_minus, now_plus
gdax = Gdax()
yesterday = now_minus(hours=6)
today = now_plus(hours=12)
FIXTURES_DIR = os.path.join(os.path.dirname(__file__), 'fixtures')
def test_chart_rsi():
fp = os.path.join(FIXTURES_DIR, 'btc_test_chart.csv')
c = GdaxChartData(gdax,
'BTC-USD',
yesterday,
today,
granularity=60*5,)
c.df.to_csv(fp, index=False)
"""
from stocklook.crypto.gdax import Gdax, GdaxProducts, GdaxOrderBook, GdaxChartData, get_buypoint, GdaxDatabase
from stocklook.utils.timetools import now_minus, now
if __name__ == '__main__':
g = Gdax()
#for a in g.accounts.values():
# print(a)
# print("\n")
# print("Total account value: ${}".format(g.get_total_value()))
pair = GdaxProducts.LTC_USD
book = GdaxOrderBook(g, pair)
product = g.get_product(pair)
start = now_minus(days=5)
end = now()
granularity = 60 * 60 * 24
chart = GdaxChartData(g, pair, start, end, granularity)
price = product.price
res_price, res_qty = book.get_next_resistance()
su_price, su_qty = book.get_next_support()
avg_vol = int(chart.avg_vol)
avg_range = round(chart.avg_range, 2)
avg_close = round(chart.avg_close, 2)
avg_rsi = round(chart.avg_rsi, 2)
cdf = chart.df
bdf = book.get_data_frame()
def sync_chart_data(self):
"""
Ensures GdaxChartData objects are created and kept up-to-date.
These objects are assigned to GdaxAnalyzer objects so they'll
all be analyzing the same set(s) of data refreshed on a timely basis.
ChartData objects are assigned as follows:
GdaxTrader.h: 4 hours of data, 5 minutes timeframes
GdaxTrader.d: 1 day of data, 15 minutes timeframes
GdaxTrader.w: 1 week of data, 4 hours timeframes
GdaxTrader.m 1 month of data, 4 hours timeframes
Default Timeframes are as follows:
GdaxTrader.h: 3 minute refreshes - most-up-to-date
GdaxTrader.d: 15 minute refreshes
GdaxTrader.w: 2 hour refreshes
GdaxTrader.m: 6 hour refreshes
:return:
"""
times = self.get_next_sync_times()
t = now()
h_due = times['h'] <= t
d_due = times['d'] <= t
w_due = times['w'] <= t
m_due = times['m'] <= t
# Hour Chart
if self.h is None or h_due:
start, end = now_minus(hours=4), now()
granularity = 60 * 5
if self.h is None:
self.h = GdaxChartData(self.gdax,
self.product,
start,
end,
granularity)
else:
self.h.refresh(start=start, end=end)
self.times['h'] = end
# Day chart
if self.d is None or d_due:
start, end = now_minus(hours=24), now()
granularity = 60 * 15
if self.d is None:
self.d = GdaxChartData(self.gdax,
self.product,
start,
end,
granularity)
else:
self.d.refresh(start=start, end=end)
self.times['d'] = end
# Week chart
if self.w is None or w_due:
start = now_minus(days=7)
end = now()
granularity = 60 * 60 * 4
if self.w is None:
self.w = GdaxChartData(self.gdax,
self.product,
start,
end,
granularity)
else:
self.w.refresh(start=start, end=end)
self.times['w'] = end
# Month chart
if self.m is None or m_due:
start = now_minus(months=1)
end = now()
granularity = 60 * 60 * 24
if self.m is None:
self.m = GdaxChartData(self.gdax,
self.product,
start,
end,
granularity)
else:
self.m.refresh(start=start, end=end)
self.times['m'] = end
book = self.gdax.get_book(self.product)
# Make sure analyzers aren't missing charts.
# if h chart is missing all are probably missing.
for a in self.analyzers.values():
if a.h is None:
a.register_data(self.h, self.d, self.w, self.m)
return self.h, self.d, self.w, self.m
strat_df.to_csv(pout_path, index=False)
trade_df.to_csv(tout_path, index=False)
print("Done: {}".format(out_path))
try:
top_id = int(strat_df.iloc[0]['maker_id'])
print("Top decision maker: {}".format(strat.makers[top_id]))
except:
pass
return tout_path, trade_df
if __name__ == '__main__':
data_dir = config['DATA_DIRECTORY']
product = 'LTC-USD'
day_range = 60
start = now_minus(days=60)
end = now()
granularity = 60 * 60 * 4
grans = [(60 * 60, 4), (60 * 15, 3)]
results = list()
for i in range(30):
fp, df = run_macd_rsi_decisions(data_dir,
product,
start,
end,
granularity,
overwrite=False)
results.append((fp, df))
start -= pd.DateOffset(day_range)
end -= pd.DateOffset(day_range)