def get_benchmark_asset(exchange):
BTC_USD = Asset(coins.BTC, coins.USD)
BTC_USDT = Asset(coins.BTC, coins.USDT)
markets = exchange.get_markets()
if BTC_USD.symbol in markets:
return BTC_USD
elif BTC_USDT.symbol in markets:
return BTC_USDT
return None
def from_config(self, config):
root = os.path.join(cfg.DATA_DIR, config['experiment'])
store = DATA_STORES[cfg.DATA_STORE](root)
feed = load_feed(
name=config['feed']['name'],
fpath=config['feed']['fpath'],
assets=[Asset.from_symbol(a) for a in config['feed']['symbols']],
timeframe=Timeframe[config['feed']['timeframe']],
start=str_to_date(config['feed'].get('start')),
end=str_to_date(config['feed'].get('end')),
)
feed.initialize(exchange)
perf = PerformanceTracker(
starting_cash=config['starting_cash'],
timeframe=Timeframe[config['feed']['timeframe']],
store=store)
record = Record(config=cfg,
portfolio=Portfolio(config['cash_currency'],
config['starting_cash'], perf),
balance=Balance.from_dict(config['balance']),
store=store)
exchange = load_exchange(config['exchange']['exchange_id'],
cfg=config['exchange'])
logger = get_logger(fpath=root,
logger_name='progress',
ch_log_level=logging.INFO)
return Context(exchange=exchange,
feed=feed,
record=record,
logger=logger)
def from_dict(self, d):
return Trade(trade_id=d.get("id"),
exchange_id=d['exchange_id'],
exchange_order_id=d['order'],
asset=Asset.from_symbol(d['symbol']),
price=d['price'],
quantity=d['amount'],
trade_time=str_to_date(d['datetime']),
side=TradeSide.from_side(d['side']),
fee=d['fee'])
def cash_coins(self):
cash = set()
columns = [c for c in self.ohlcv_df.columns if c not in ['utc', 'epoch']]
for col in columns:
field,symbol,ex_id = col.split('_')
asset = Asset.from_symbol(symbol)
if asset.quote in [coins.USD, coins.USDT]:
cash.add(coins.USD)
else:
cash.add(asset.quote)
return cash
def get_assets(self, exchange_id=None):
cols = ([
col for col in self.record.ohlcv.columns
if col not in ['epoch', 'utc']
])
symbols = set()
for col in cols:
field, symbol, ex_id = col.split('_')
if exchange_id is None or exchange_id == ex_id:
symbols.add(symbol)
return [Asset.from_symbol(sym) for sym in symbols]
def from_dict(self, d):
order = ExchangeOrder(
ex_order_id=d['id'],
exchange_id=d['exchange_id'],
asset=Asset.from_symbol(d['symbol']),
price=d['price'],
quantity=d['amount'],
filled_quantity=d['filled'],
order_type=OrderType.from_type_side(d['type'], d['side']),
status=OrderStatus[d['status']],
)
order.opened_time = str_to_date(d['datetime'])
order.filled_time = str_to_date(d.get('filled_time'))
order.canceled_time = str_to_date(d.get('canceled_time'))
order.fee = d.get('fee', {})
return order
def from_dict(self, d):
order = Order(exchange_id=d['exchange_id'],
asset=Asset.from_symbol(d['symbol']),
price=d['price'],
quantity=d['quantity'],
order_type=OrderType[d['order_type']],
created_time=str_to_date(d['created_time']))
order.id = d['id']
order.exchange_order_id = d['exchange_order_id']
order.filled_quantity = d['filled_quantity']
order.status = OrderStatus[d['status']]
order.opened_time = str_to_date(d['opened_time'])
order.filled_time = str_to_date(d['filled_time'])
order.canceled_time = str_to_date(d['canceled_time'])
order.attempts = d['attempts']
order.fee = d['fee']
order.error = OrderingError.from_dict(d['error'])
return order
def asset():
return Asset.from_symbol("BTC/USDT")
# Add Metrics and OHLCV to Record
self.update_metric('SMA', 5.0, ctx)
self.update_metric('RSI', 10.0, ctx)
self.update_ohlcv(data, ctx)
print(current_time)
self.log_all(new_orders, data, ctx, current_time)
return {'new_orders': new_orders, 'cancel_ids': cancel_ids}
if __name__ == "__main__":
args = parser.parse_args()
experiment_name = args.name + '_' + args.mode
trade_mode = TradeMode[args.mode.upper()]
timeframe = Timeframe.from_id(args.timeframe)
starting_cash = args.cash
asset = Asset.from_symbol(args.asset)
quantity = args.quantity
cash_currency = asset.quote
plot = args.plot
verbose = args.verbose
ohlcv_fpath = args.ohlcv_fpath
exchange_id = args.exchange_id
print(("\nExperiment \n----------------------\n" + "Name: {:s}\n" +
"TradeMode: {:s}\n" + "Timeframe: {:s}\n" + "Asset: {:s}\n" +
"Quantity: {:.4f}\n" + "StartingCash: {:4f}\n" + "OHLCV: {:s}\n" +
"Exchange: {:s}\n" + "----------------------\n").format(
experiment_name, trade_mode.name, timeframe.id, asset.symbol,
quantity, starting_cash, ohlcv_fpath, exchange_id))
print((
data = exchange.fetch_order_book(asset, depth)
fname = get_order_book_fname(exchange_id, asset)
fpath = Path(ORDER_BOOK_DIR, fname)
utils.files.save_dct(fpath, data, mode='a+')
return fpath
def run(exchange_ids, assets, depth, upload):
for ex_id in exchanges:
for asset in assets:
print('Downloading', ex_id, asset.symbol)
fpath = download_and_save_order_book_data(ex_id, asset, depth)
if upload:
s3_path = get_s3_path(ex_id, asset)
print('Uploading to s3:' ,s3_path)
s3_client.upload_file(str(fpath), s3_path)
if __name__ == "__main__":
args = parser.parse_args()
exchanges = args.exchanges
assets = [Asset.from_symbol(s) for s in args.symbols]
depth = args.depth
refresh = args.refresh
upload = args.upload
print('Downloading order book for: ', args.exchanges,
'Assets:', args.symbols, 'refresh sec:', refresh)
while True:
run(exchanges, assets, depth, upload)
time.sleep(refresh)