def __init__(self, address, pairs=None, channels=None, config=None, callbacks=None, book_interval=1000): self.hash = str(uuid.uuid4()) self.uuid = self.id + self.hash self.config = {} self.address = address self.book_update_interval = book_interval self.updates = 0 self.do_deltas = False self.pairs = [] self.channels = [] load_exchange_pair_mapping(self.id) if config is not None and (pairs is not None or channels is not None): raise ValueError("Use config, or channels and pairs, not both") if config is not None: for channel in config: chan = feed_to_exchange(self.id, channel) self.config[chan] = [ pair_std_to_exchange(pair, self.id) for pair in config[channel] ] if pairs: self.pairs = [ pair_std_to_exchange(pair, self.id) for pair in pairs ] if channels: self.channels = [ feed_to_exchange(self.id, chan) for chan in channels ] self.l3_book = {} self.l2_book = {} self.callbacks = { TRADES: Callback(None), TICKER: Callback(None), L2_BOOK: Callback(None), L3_BOOK: Callback(None), VOLUME: Callback(None), FUNDING: Callback(None), INSTRUMENT: Callback(None) } if callbacks: for cb_type, cb_func in callbacks.items(): self.callbacks[cb_type] = cb_func if cb_type == BOOK_DELTA: self.do_deltas = True for key, callback in self.callbacks.items(): if not isinstance(callback, list): self.callbacks[key] = [callback]
def __init__(self, address, pairs=None, channels=None, config=None, callbacks=None, book_interval=1000): self.config = {} self.address = address self.book_update_interval = book_interval self.updates = 0 self.do_deltas = False self.pairs = [] self.channels = [] load_exchange_pair_mapping(self.id) if channels is not None and FUNDING in channels and self.id == BITFINEX: if len(channels) > 1: raise ValueError( "Funding channel must be in a separate feedhanlder on Bitfinex or you must use config" ) if config is not None and (pairs is not None or channels is not None): raise ValueError("Use config, or channels and pairs, not both") if config is not None: for channel in config: chan = feed_to_exchange(self.id, channel) self.config[chan] = [ pair_std_to_exchange(pair, self.id) for pair in config[channel] ] if pairs: self.pairs = [ pair_std_to_exchange(pair, self.id) for pair in pairs ] if channels: self.channels = [ feed_to_exchange(self.id, chan) for chan in channels ] self.l3_book = {} self.l2_book = {} self.callbacks = { TRADES: Callback(None), TICKER: Callback(None), L2_BOOK: Callback(None), L3_BOOK: Callback(None), VOLUME: Callback(None), FUNDING: Callback(None) } if callbacks: for cb_type, cb_func in callbacks.items(): self.callbacks[cb_type] = cb_func if cb_type == BOOK_DELTA: self.do_deltas = True
def __getitem__(self, key): if not self.mapped: load_exchange_pair_mapping(self.ID) self.mapped = True if key == 'trades': return self.trades elif key == 'funding': return self.funding
def __getattr__(self, attr): exch = self.lookup[attr.lower()] if not exch.mapped: try: load_exchange_pair_mapping(exch.ID + 'REST') except KeyError: load_exchange_pair_mapping(exch.ID) exch.mapped = True return exch
def __init__(self, address, pairs=None, channels=None, config=None, callbacks=None, max_depth=None, book_interval=1000, cross_check=False, origin=None): self.hash = str(uuid.uuid4()) self.uuid = self.id + self.hash self.config = defaultdict(set) self.address = address self.book_update_interval = book_interval self.cross_check = cross_check self.updates = defaultdict(int) self.do_deltas = False self.pairs = [] self.channels = [] self.max_depth = max_depth self.previous_book = defaultdict(dict) self.origin = origin load_exchange_pair_mapping(self.id) if config is not None and (pairs is not None or channels is not None): raise ValueError("Use config, or channels and pairs, not both") if config is not None: for channel in config: chan = feed_to_exchange(self.id, channel) self.config[chan].update([pair_std_to_exchange(pair, self.id) for pair in config[channel]]) if pairs: self.pairs = [pair_std_to_exchange(pair, self.id) for pair in pairs] if channels: self.channels = list(set([feed_to_exchange(self.id, chan) for chan in channels])) self.l3_book = {} self.l2_book = {} self.callbacks = { TICKER_OKS: Callback(None), TICKER_FUTURES: Callback(None),TRADES: Callback(None), TICKER: Callback(None), L2_BOOK: Callback(None), L3_BOOK: Callback(None), VOLUME: Callback(None), FUNDING: Callback(None), OPEN_INTEREST: Callback(None), LIQUIDATIONS: Callback(None)} if callbacks: for cb_type, cb_func in callbacks.items(): self.callbacks[cb_type] = cb_func if cb_type == BOOK_DELTA: self.do_deltas = True for key, callback in self.callbacks.items(): if not isinstance(callback, list): self.callbacks[key] = [callback]
def __init__(self, config, sandbox=False): load_exchange_pair_mapping(self.ID) path = os.path.dirname(os.path.abspath(__file__)) self.key_id, self.key_secret, self.key_passphrase = None, None, None self.sandbox = sandbox if not config: config = "config.yaml" try: with open(os.path.join(path, config), 'r') as fp: data = yaml.safe_load(fp) self.key_id = data[self.ID.lower()]['key_id'] self.key_secret = data[self.ID.lower()]['key_secret'] if 'key_passphrase' in data[self.ID.lower()]: self.key_passphrase = data[self.ID.lower()]['key_passphrase'] except (KeyError, FileNotFoundError, TypeError): pass
def __getitem__(self, key): if not self.mapped: try: load_exchange_pair_mapping(self.ID + 'REST') except KeyError: load_exchange_pair_mapping(self.ID) self.mapped = True if key == 'trades': return self.trades elif key == 'funding': return self.funding elif key == 'l2_book': return self.l2_book elif key == 'l3_book': return self.l3_book elif key == 'ticker': return self.ticker
def __getattr__(self, attr): exch = self.lookup[attr.lower()] if not exch.mapped: load_exchange_pair_mapping(exch.ID) exch.mapped = True return exch
def test_bitfinex_pair_conversions(): load_exchange_pair_mapping(BITFINEX) for _, pair in bitfinex_pairs().items(): std = pair_exchange_to_std(pair) assert (pair == pair_std_to_exchange(std, BITFINEX))
def __init__(self, address, pairs=None, channels=None, config=None, callbacks=None, max_depth=None, book_interval=1000, snapshot_interval=False, checksum_validation=False, cross_check=False, origin=None): """ max_depth: int Maximum number of levels per side to return in book updates book_interval: int Number of updates between snapshots. Only applicable when book deltas are enabled. Book deltas are enabled by subscribing to the book delta callback. snapshot_interval: bool/int Number of updates between snapshots. Only applicable when book delta is not enabled. Updates between snapshots are not delivered to the client checksum_validation: bool Toggle checksum validation, when supported by an exchange. cross_check: bool Toggle a check for a crossed book. Should not be needed on exchanges that support checksums or provide message sequence numbers. origin: str Passed into websocket connect. Sets the origin header. """ self.hash = str(uuid.uuid4()) self.uuid = f"{self.id}-{self.hash}" self.config = defaultdict(set) self.address = address self.book_update_interval = book_interval self.snapshot_interval = snapshot_interval self.cross_check = cross_check self.updates = defaultdict(int) self.do_deltas = False self.pairs = [] self.channels = [] self.max_depth = max_depth self.previous_book = defaultdict(dict) self.origin = origin self.checksum_validation = checksum_validation load_exchange_pair_mapping(self.id) if config is not None and (pairs is not None or channels is not None): raise ValueError("Use config, or channels and pairs, not both") if config is not None: for channel in config: chan = feed_to_exchange(self.id, channel) self.config[chan].update([ pair_std_to_exchange(pair, self.id) for pair in config[channel] ]) if pairs: self.pairs = [ pair_std_to_exchange(pair, self.id) for pair in pairs ] if channels: self.channels = list( set([feed_to_exchange(self.id, chan) for chan in channels])) self.l3_book = {} self.l2_book = {} self.callbacks = { TRADES: Callback(None), TICKER: Callback(None), L2_BOOK: Callback(None), L3_BOOK: Callback(None), VOLUME: Callback(None), FUNDING: Callback(None), OPEN_INTEREST: Callback(None), LIQUIDATIONS: Callback(None), FUTURES_INDEX: Callback(None) } if callbacks: for cb_type, cb_func in callbacks.items(): self.callbacks[cb_type] = cb_func if cb_type == BOOK_DELTA: self.do_deltas = True for key, callback in self.callbacks.items(): if not isinstance(callback, list): self.callbacks[key] = [callback]
def get_active_symbols(): load_exchange_pair_mapping(Upbit.id) symbols = [] for data in Upbit.get_active_symbols_info(): symbols.append(pair_exchange_to_std(data['market'])) return symbols
def test_bitcoincom_pair_conversions(): load_exchange_pair_mapping(BITCOINCOM) for _, pair in bitcoincom_pairs().items(): std = pair_exchange_to_std(pair) assert (pair == pair_std_to_exchange(std, BITCOINCOM))
def test_blockchain_pair_conversions(): load_exchange_pair_mapping(BLOCKCHAIN) for _, pair in blockchain_pairs().items(): assert (pair_exchange_to_std(pair) == pair_std_to_exchange( pair, BLOCKCHAIN))
def test_gemini_pair_conversions(): load_exchange_pair_mapping(GEMINI) for _, pair in gemini_pairs().items(): std = pair_exchange_to_std(pair) assert (pair == pair_std_to_exchange(std, GEMINI))
def test_bitstamp_pair_conversions(): load_exchange_pair_mapping(BITSTAMP) for _, pair in bitstamp_pairs().items(): std = pair_exchange_to_std(pair) assert (pair == pair_std_to_exchange(std, BITSTAMP))
def test_hitbtc_pair_conversions(): load_exchange_pair_mapping(HITBTC) for _, pair in hitbtc_pairs().items(): std = pair_exchange_to_std(pair) assert (pair == pair_std_to_exchange(std, HITBTC))
def __getitem__(self, key): exch = self.lookup[key.lower()] if not exch.mapped: load_exchange_pair_mapping(exch.ID) exch.mapped = True return exch
def test_poloniex_pair_conversions(): load_exchange_pair_mapping(POLONIEX) for _, pair in poloniex_pairs().items(): std = pair_exchange_to_std(pair) assert (pair == pair_std_to_exchange(std, POLONIEX))
def test_dsx_pair_conversion(): load_exchange_pair_mapping(DSX) for _, pair in dsx_pairs().items(): std = pair_exchange_to_std(pair) assert (pair == pair_std_to_exchange(std, DSX))
def test_coinbase_pair_conversions(): load_exchange_pair_mapping(COINBASE) for _, pair in coinbase_pairs().items(): assert (pair_exchange_to_std(pair) == pair_std_to_exchange( pair, COINBASE))