def main(proxy):
futures_symbols = BinanceFutures.info()['symbols']
futures_symbols = [
symbol for symbol in futures_symbols if 'PINDEX' not in symbol
]
shuffle(futures_symbols)
futures_symbols = futures_symbols[:20]
# use high volume pairs for quick l2_book updates
book_symbols = [
'ETH-BTC', 'LTC-BTC', 'ADA-BTC', 'BTC-USDT', 'ETH-USDT', 'LTC-USDT',
'BNB-BTC', 'BNB-ETH'
]
f = FeedHandler()
counter = Counter(f)
f.add_feed(
Binance(depth_interval='1000ms',
http_proxy=proxy,
max_depth=1,
symbols=book_symbols,
channels=[L2_BOOK],
callbacks={
L2_BOOK:
counter.callback(BINANCE, L2_BOOK, book_symbols, False)
}))
f.add_feed(
Binance(depth_interval='1000ms',
http_proxy=proxy,
max_depth=1,
symbols=book_symbols,
channels=[L2_BOOK],
callbacks={
L2_BOOK: counter.callback(BINANCE, L2_BOOK, book_symbols,
True)
}))
f.add_feed(
BinanceFutures(http_proxy=proxy,
open_interest_interval=1.0,
symbols=futures_symbols,
channels=[OPEN_INTEREST],
callbacks={
OPEN_INTEREST:
counter.callback(BINANCE_FUTURES, OPEN_INTEREST,
futures_symbols, False)
}))
f.add_feed(
BinanceFutures(http_proxy=proxy,
open_interest_interval=1.0,
symbols=futures_symbols,
channels=[OPEN_INTEREST],
callbacks={
OPEN_INTEREST:
counter.callback(BINANCE_FUTURES, OPEN_INTEREST,
futures_symbols, True)
}))
f.run()
def main():
config = {'log': {'filename': 'redis-demo.log', 'level': 'INFO'}}
f = FeedHandler(config=config)
f.add_feed(Bitmex(channels=[TRADES, FUNDING, OPEN_INTEREST], symbols=['BTC-USD-PERP'], callbacks={TRADES: TradeRedis(), FUNDING: FundingRedis(), OPEN_INTEREST: OpenInterestRedis()}))
f.add_feed(Bitfinex(channels=[TRADES], symbols=['BTC-USD'], callbacks={TRADES: TradeRedis()}))
f.add_feed(Coinbase(channels=[TRADES], symbols=['BTC-USD'], callbacks={TRADES: TradeRedis()}))
f.add_feed(Coinbase(channels=[L2_BOOK], symbols=['BTC-USD'], callbacks={L2_BOOK: BookStream()}))
f.add_feed(Gemini(symbols=['BTC-USD'], callbacks={TRADES: TradeRedis()}))
f.add_feed(Binance(candle_closed_only=True, symbols=['BTC-USDT'], channels=[CANDLES], callbacks={CANDLES: CandlesRedis(score_key='start')}))
f.add_feed(Binance(max_depth=10, symbols=['BTC-USDT'], channels=[L2_BOOK], callbacks={L2_BOOK: BookRedis(snapshots_only=True)}))
f.run()
def main():
addr = 'tcp://localhost'
port = 8189
f = FeedHandler()
f.add_feed(
Coinbase(channels=[TRADES],
symbols=['BTC-USD'],
callbacks={
TRADES: TradeVictoriaMetrics(addr, port, 'demo-trades')
}))
f.add_feed(
Coinbase(channels=[TICKER],
symbols=['BTC-USD'],
callbacks={
TICKER: TickerVictoriaMetrics(addr, port, 'demo-tickers')
}))
f.add_feed(
Coinbase(channels=[L2_BOOK],
symbols=['BTC-USD'],
callbacks={
L2_BOOK: BookVictoriaMetrics(addr, port, 'demo-book'),
BOOK_DELTA:
BookDeltaVictoriaMetrics(addr, port, 'demo-book')
}))
f.add_feed(
Binance(channels=[CANDLES],
symbols=['BTC-USDT'],
callbacks={
CANDLES: CandlesVictoriaMetrics(addr, port, 'demo-candles')
}))
f.run()
def main():
f = FeedHandler()
f.add_feed(
Bitmex(channels=[TRADES, FUNDING, OPEN_INTEREST],
symbols=['BTC-USD'],
callbacks={
TRADES: TradeRedis(),
FUNDING: FundingRedis(),
OPEN_INTEREST: OpenInterestRedis()
}))
f.add_feed(
Bitfinex(channels=[TRADES],
symbols=['BTC-USD'],
callbacks={TRADES: TradeRedis()}))
f.add_feed(
Coinbase(channels=[TRADES],
symbols=['BTC-USD'],
callbacks={TRADES: TradeRedis()}))
f.add_feed(
Coinbase(max_depth=10,
channels=[L2_BOOK],
symbols=['BTC-USD'],
callbacks={L2_BOOK: BookRedis()}))
f.add_feed(Gemini(symbols=['BTC-USD'], callbacks={TRADES: TradeRedis()}))
f.add_feed(
Binance(symbols=['BTC-USDT'],
channels=[CANDLES],
callbacks={CANDLES: CandlesStream()}))
f.run()
def main():
f = FeedHandler()
# Note: EXX is extremely unreliable - sometimes a connection can take many many retries
# f.add_feed(EXX(pairs=['BTC-USDT'], channels=[L2_BOOK, TRADES], callbacks={L2_BOOK: BookCallback(book), TRADES: TradeCallback(trade)}))
f.add_feed(
Binance(pairs=['BTC-USDT'],
channels=[TRADES, TICKER, L2_BOOK],
callbacks={
L2_BOOK: BookCallback(book),
TRADES: TradeCallback(trade),
TICKER: TickerCallback(ticker)
}))
f.add_feed(COINBASE,
pairs=['BTC-USD'],
channels=[TICKER],
callbacks={TICKER: TickerCallback(ticker)})
f.add_feed(
Coinbase(pairs=['BTC-USD'],
channels=[TRADES],
callbacks={TRADES: TradeCallback(trade)}))
f.add_feed(
Coinbase(config={
L2_BOOK: ['BTC-USD', 'ETH-USD'],
TRADES: ['ETH-USD', 'BTC-USD']
},
callbacks={
TRADES: TradeCallback(trade),
L2_BOOK: BookCallback(book)
}))
f.run(start_loop=False)
loop = asyncio.get_event_loop()
loop.create_task(aio_task())
loop.run_forever()
def main():
f = FeedHandler()
# Note: EXX is extremely unreliable - sometimes a connection can take many many retries
# f.add_feed(EXX(pairs=['BTC-USDT'], channels=[L2_BOOK, TRADES], callbacks={L2_BOOK: BookCallback(book), TRADES: TradeCallback(trade)}))
f.add_feed(Binance(pairs=['BTC-USDT'], channels=[TRADES, TICKER, L2_BOOK], callbacks={L2_BOOK: BookCallback(book), TRADES: TradeCallback(trade), TICKER: TickerCallback(ticker)}))
f.add_feed(COINBASE, pairs=['BTC-USD'], channels=[TICKER], callbacks={TICKER: TickerCallback(ticker)})
f.add_feed(Coinbase(pairs=['BTC-USD'], channels=[TRADES], callbacks={TRADES: TradeCallback(trade)}))
f.add_feed(Coinbase(pairs=['BTC-USD'], channels=[L2_BOOK], callbacks={L2_BOOK: BookCallback(book)}))
f.add_feed(Bitfinex(pairs=['BTC-USD'], channels=[L2_BOOK], callbacks={L2_BOOK: BookCallback(book)}))
f.add_feed(Poloniex(pairs=['BTC-USDT', 'BTC-USDC'], channels=[TICKER, TRADES], callbacks={TICKER: TickerCallback(ticker), TRADES: TradeCallback(trade)}))
f.add_feed(Poloniex(config={TRADES: ['DOGE-BTC', 'ETH-BTC'], TICKER: ['ETH-BTC'], L2_BOOK: ['LTC-BTC']}, callbacks={TRADES: TradeCallback(trade), TICKER: TickerCallback(ticker), L2_BOOK: BookCallback(book)}))
f.add_feed(Gemini(config={L2_BOOK: ['BTC-USD', 'ETH-USD'], TRADES: ['ETH-USD', 'BTC-USD']}, callbacks={TRADES: TradeCallback(trade), L2_BOOK: BookCallback(book)}))
f.add_feed(HitBTC(channels=[TRADES], pairs=['BTC-USD'], callbacks={TRADES: TradeCallback(trade)}))
f.add_feed(HitBTC(channels=[L2_BOOK], pairs=['BTC-USD'], callbacks={L2_BOOK: BookCallback(book)}))
f.add_feed(Bitstamp(channels=[L2_BOOK, TRADES], pairs=['BTC-USD'], callbacks={L2_BOOK: BookCallback(book), TRADES: TradeCallback(trade)}))
bitmex_symbols = Bitmex.get_active_symbols()
f.add_feed(Bitmex(channels=[INSTRUMENT], pairs=['XBTUSD'], callbacks={INSTRUMENT: InstrumentCallback(instrument)}))
f.add_feed(Bitmex(channels=[TRADES], pairs=bitmex_symbols, callbacks={TRADES: TradeCallback(trade)}))
f.add_feed(Bitmex(pairs=['XBTUSD'], channels=[FUNDING, TRADES], callbacks={FUNDING: FundingCallback(funding), TRADES: TradeCallback(trade)}))
f.add_feed(Bitfinex(pairs=['BTC'], channels=[FUNDING], callbacks={FUNDING: FundingCallback(funding)}))
f.add_feed(Bitmex(pairs=['XBTUSD'], channels=[L2_BOOK], callbacks={L2_BOOK: BookCallback(book)}))
f.add_feed(Kraken(config={TRADES: ['BTC-USD'], TICKER: ['ETH-USD']}, callbacks={TRADES: TradeCallback(trade), TICKER: TickerCallback(ticker)}))
config={TRADES: ['BTC-USD', 'ETH-USD', 'BTC-USDT', 'ETH-USDT'], L2_BOOK: ['BTC-USD', 'BTC-USDT']}
f.add_feed(HuobiUS(config=config, callbacks={TRADES: TradeCallback(trade), L2_BOOK: BookCallback(book)}))
config={TRADES: ['BTC-USDT', 'ETH-USDT'], L2_BOOK: ['BTC-USDT']}
f.add_feed(Huobi(config=config, callbacks={TRADES: TradeCallback(trade), L2_BOOK: BookCallback(book)}))
f.add_feed(OKCoin(pairs=['BTC-USD'], channels=[L2_BOOK], callbacks={L2_BOOK: BookCallback(book)}))
f.add_feed(OKEx(pairs=['BTC-USDT'], channels=[TRADES], callbacks={TRADES: TradeCallback(trade)}))
f.add_feed(Coinbene(channels=[L2_BOOK, TRADES, TICKER], pairs=['BTC-USDT'], callbacks={L2_BOOK: BookCallback(book), TICKER: TickerCallback(ticker), TRADES: TradeCallback(trade)}))
f.run()
def test_binance_address_generation():
symbols = Binance.symbols()
channels = [
channel for channel in Binance.info()['channels']['websocket']
if not Binance.is_authenticated_channel(channel)
]
for length in (10, 20, 30, 40, 50, 100, 200, 500, len(symbols)):
syms = []
chans = []
sub = random.sample(symbols, length)
addr = Binance(symbols=sub, channels=channels)._address()
if length * len(channels) < 200:
assert isinstance(addr, str)
value = addr.split("=", 1)[1]
value = value.split("/")
for entry in value:
sym, chan = entry.split("@", 1)
syms.append(sym)
chans.append(chan)
else:
assert isinstance(addr, list)
for value in addr:
value = value.split("=", 1)[1]
value = value.split("/")
for entry in value:
sym, chan = entry.split("@", 1)
syms.append(sym)
chans.append(chan)
assert len(chans) == len(channels) * length == len(syms)
assert len(set(chans)) == len(channels)
assert (len(set(syms))) == length
def main():
f = FeedHandler()
f.run(start_loop=False)
f.add_feed(
Binance(symbols=['BTC-USDT'],
channels=[TRADES, TICKER, L2_BOOK],
callbacks={
L2_BOOK: book,
TRADES: trade,
TICKER: ticker
}))
f.add_feed(COINBASE,
symbols=['BTC-USD'],
channels=[TICKER],
callbacks={TICKER: ticker})
f.add_feed(
Coinbase(symbols=['BTC-USD'],
channels=[TRADES],
callbacks={TRADES: trade}))
f.add_feed(
Coinbase(subscription={
L2_BOOK: ['BTC-USD', 'ETH-USD'],
TRADES: ['ETH-USD', 'BTC-USD']
},
callbacks={
TRADES: trade,
L2_BOOK: book
}))
loop = asyncio.get_event_loop()
loop.create_task(aio_task())
loop.run_forever()
def test_binance_address_generation():
symbols = Binance.info()['symbols']
channels = Binance.info()['channels']
for length in (10, 20, 30, 40, 50, 100, 200, 500, len(symbols)):
syms = []
chans = []
sub = random.sample(symbols, length)
addr = Binance(symbols=sub, channels=channels)._address()
if length * len(channels) < 200:
assert isinstance(addr, str)
value = addr.split("=", 1)[1]
value = value.split("/")
for entry in value:
sym, chan = entry.split("@", 1)
syms.append(sym)
chans.append(chan)
else:
assert isinstance(addr, dict)
for _, value in addr.items():
value = value.split("=", 1)[1]
value = value.split("/")
for entry in value:
sym, chan = entry.split("@", 1)
syms.append(sym)
chans.append(chan)
assert len(chans) == len(channels) * length == len(syms)
assert len(set(chans)) == len(channels)
assert (len(set(syms))) == length
def main():
f = FeedHandler()
# Note: EXX is extremely unreliable - sometimes a connection can take many many retries
# f.add_feed(EXX(pairs=['BTC-USDT'], channels=[L2_BOOK, TRADES], callbacks={L2_BOOK: BookCallback(book), TRADES: TradeCallback(trade)}))
f.add_feed(Binance(pairs=['BTC-USDT'], channels=[TRADES, TICKER, L2_BOOK], callbacks={L2_BOOK: BookCallback(book), TRADES: TradeCallback(trade), TICKER: TickerCallback(ticker)}))
f.add_feed(COINBASE, pairs=['BTC-USD'], channels=[TICKER], callbacks={TICKER: TickerCallback(ticker)})
f.add_feed(Coinbase(pairs=['BTC-USD'], channels=[TRADES], callbacks={TRADES: TradeCallback(trade)}))
f.add_feed(Coinbase(pairs=['BTC-USD'], channels=[L2_BOOK], callbacks={L2_BOOK: BookCallback(book)}))
f.add_feed(Bitfinex(pairs=['BTC-USD'], channels=[L2_BOOK], callbacks={L2_BOOK: BookCallback(book)}))
f.add_feed(Poloniex(channels=[TICKER, 'BTC-USDT', 'BTC-USDC'], callbacks={L2_BOOK: BookCallback(book), TICKER: TickerCallback(ticker)}))
f.add_feed(Poloniex(channels=['BTC-USDT', 'BTC-USDC'], callbacks={TRADES: TradeCallback(trade)}))
f.add_feed(Gemini(pairs=['BTC-USD'], callbacks={L2_BOOK: BookCallback(book), TRADES: TradeCallback(trade)}))
f.add_feed(HitBTC(channels=[TRADES], pairs=['BTC-USD'], callbacks={TRADES: TradeCallback(trade)}))
f.add_feed(HitBTC(channels=[L2_BOOK], pairs=['BTC-USD'], callbacks={L2_BOOK: BookCallback(book)}))
f.add_feed(Bitstamp(channels=[L2_BOOK, TRADES], pairs=['BTC-USD'], callbacks={L2_BOOK: BookCallback(book), TRADES: TradeCallback(trade)}))
bitmex_symbols = Bitmex.get_active_symbols()
f.add_feed(Bitmex(channels=[TRADES], pairs=bitmex_symbols, callbacks={TRADES: TradeCallback(trade)}))
f.add_feed(Bitmex(pairs=['XBTUSD'], channels=[FUNDING, TRADES], callbacks={FUNDING: FundingCallback(funding), TRADES: TradeCallback(trade)}))
f.add_feed(Bitfinex(pairs=['BTC'], channels=[FUNDING], callbacks={FUNDING: FundingCallback(funding)}))
f.add_feed(Bitmex(pairs=['XBTUSD'], channels=[L3_BOOK], callbacks={L3_BOOK: BookCallback(book)}))
f.add_feed(Kraken(pairs=['BTC-USD'], channels=[TRADES, TICKER, L2_BOOK], callbacks={TRADES: TradeCallback(trade), TICKER: TickerCallback(ticker), L2_BOOK: BookCallback(book)}))
f.run()
def main():
config = {'log': {'filename': 'demo.log', 'level': 'INFO'}}
# the config will be automatically passed into any exchanges set up by string. Instantiated exchange objects would need to pass the config in manually.
f = FeedHandler(config=config)
# Note: EXX is extremely unreliable - sometimes a connection can take many many retries
# from cryptofeed.exchanges import EXX
# f.add_feed(EXX(symbols=['BTC-USDT'], channels=[L2_BOOK, TRADES], callbacks={L2_BOOK: BookCallback(book), TRADES: TradeCallback(trade)}))
f.add_feed(Gateio(symbols=['BTC-USDT', 'ETH-USDT'], channels=[TRADES, L2_BOOK], callbacks={TRADES: TradeCallback(trade), L2_BOOK: BookCallback(book)}))
pairs = list(binance_symbols().keys())
f.add_feed(Binance(symbols=pairs, channels=[TRADES], callbacks={TRADES: TradeCallback(trade)}))
f.add_feed(COINBASE, symbols=['BTC-USD'], channels=[TICKER], callbacks={TICKER: TickerCallback(ticker)})
f.add_feed(Coinbase(symbols=['BTC-USD'], channels=[TRADES], callbacks={TRADES: TradeCallback(trade)}))
f.add_feed(Coinbase(subscription={L2_BOOK: ['BTC-USD', 'ETH-USD'], TRADES: ['ETH-USD']}, callbacks={TRADES: TradeCallback(trade), L2_BOOK: BookCallback(book)}))
f.add_feed(Coinbase(subscription={L3_BOOK: ['LTC-USD']}, callbacks={L3_BOOK: BookCallback(book)}))
f.add_feed(Bitfinex(symbols=['BTC-USDT'], channels=[L2_BOOK], callbacks={L2_BOOK: BookCallback(book)}))
f.add_feed(Bitfinex(symbols=['BTC'], channels=[FUNDING], callbacks={FUNDING: FundingCallback(funding)}))
f.add_feed(Poloniex(symbols=['BTC-ETH'], channels=[TICKER, TRADES, VOLUME], callbacks={VOLUME: volume, TICKER: TickerCallback(ticker), TRADES: TradeCallback(trade)}))
f.add_feed(Poloniex(subscription={TRADES: ['BTC-DOGE'], L2_BOOK: ['BTC-LTC']}, callbacks={TRADES: TradeCallback(trade), TICKER: TickerCallback(ticker), L2_BOOK: BookCallback(book)}))
f.add_feed(GEMINI, subscription={L2_BOOK: ['BTC-USD', 'ETH-USD'], TRADES: ['ETH-USD', 'BTC-USD']}, callbacks={TRADES: TradeCallback(trade), L2_BOOK: BookCallback(book)})
f.add_feed(HitBTC(channels=[TRADES], symbols=['BTC-USD'], callbacks={TRADES: TradeCallback(trade)}))
f.add_feed(HitBTC(channels=[L2_BOOK], symbols=['BTC-USD'], callbacks={L2_BOOK: BookCallback(book)}))
f.add_feed(Bitstamp(channels=[L2_BOOK, TRADES], symbols=['BTC-USD'], callbacks={L2_BOOK: BookCallback(book), TRADES: TradeCallback(trade)}))
bitmex_symbols = Bitmex.info()['symbols']
f.add_feed(Bitmex(channels=[OPEN_INTEREST], symbols=['BTC-USD'], callbacks={OPEN_INTEREST: oi}))
f.add_feed(Bitmex(channels=[TRADES], symbols=bitmex_symbols, callbacks={TRADES: TradeCallback(trade)}))
f.add_feed(Bitmex(symbols=['BTC-USD'], channels=[FUNDING, TRADES], callbacks={FUNDING: FundingCallback(funding), TRADES: TradeCallback(trade)}))
f.add_feed(Bitmex(symbols=['BTC-USD'], channels=[L2_BOOK], callbacks={L2_BOOK: BookCallback(book)}))
f.add_feed(Kraken(checksum_validation=True, subscription={L2_BOOK: ['BTC-USD'], TRADES: ['BTC-USD'], TICKER: ['ETH-USD']}, callbacks={L2_BOOK: book, TRADES: TradeCallback(trade), TICKER: TickerCallback(ticker)}))
sub = {TRADES: ['BTC-USDT', 'ETH-USDT'], L2_BOOK: ['BTC-USDT']}
f.add_feed(Huobi(subscription=sub, callbacks={TRADES: TradeCallback(trade), L2_BOOK: BookCallback(book)}))
sub = {L2_BOOK: ['BTC_CQ', 'BTC_NQ']}
f.add_feed(HuobiDM(subscription=sub, callbacks={TRADES: TradeCallback(trade), L2_BOOK: BookCallback(book)}))
pairs = ['BTC-USD', 'ETH-USD', 'EOS-USD', 'BCH-USD', 'BSV-USD', 'LTC-USD']
f.add_feed(HuobiSwap(symbols=pairs, channels=[TRADES, L2_BOOK, FUNDING], callbacks={FUNDING: funding, TRADES: TradeCallback(trade), L2_BOOK: BookCallback(book)}))
f.add_feed(OKCoin(symbols=['BTC-USD'], channels=[L2_BOOK], callbacks={L2_BOOK: BookCallback(book)}))
f.add_feed(OKEx(symbols=['BTC-USDT'], channels=[TRADES], callbacks={TRADES: TradeCallback(trade)}))
f.add_feed(Bittrex(subscription={TRADES: ['BTC-USD'], TICKER: ['ETH-USD'], L2_BOOK: ['BTC-USDT']}, callbacks={L2_BOOK: BookCallback(book), TICKER: TickerCallback(ticker), TRADES: TradeCallback(trade)}))
f.add_feed(FTX(symbols=['ADA-PERP', 'ALGO-PERP', 'ALT-PERP', 'ATOM-PERP', 'BCH-PERP', 'BNB-PERP', 'BSV-PERP', 'BTC-PERP', 'BTMX-PERP', 'DOGE-PERP', 'DRGN-PERP', 'EOS-PERP', 'ETC-PERP'], channels=[TICKER], callbacks={TICKER: ticker, TRADES: TradeCallback(trade)}))
f.add_feed(Bybit(symbols=['BTC-USDT', 'BTC-USD'], channels=[FUTURES_INDEX], callbacks={OPEN_INTEREST: OpenInterestCallback(oi), FUTURES_INDEX: FuturesIndexCallback(futures_index)}))
f.add_feed(Bybit(symbols=['BTC-USDT', 'BTC-USD'], channels=[L2_BOOK, TRADES], callbacks={TRADES: trade, L2_BOOK: book}))
f.add_feed(BLOCKCHAIN, symbols=['BTC-USD', 'ETH-USD'], channels=[L2_BOOK, TRADES], callbacks={L2_BOOK: BookCallback(book), TRADES: trade})
f.add_feed(Bitmax(symbols=['XRP-USDT', 'BTC-USDT'], channels=[L2_BOOK], callbacks={TRADES: trade, L2_BOOK: book}))
f.add_feed(Bitflyer(symbols=['BTC-JPY'], channels=[L2_BOOK, TRADES, TICKER], callbacks={L2_BOOK: book, BOOK_DELTA: delta, TICKER: ticker, TRADES: trade}))
f.add_feed(BinanceFutures(symbols=['BTC-USDT'], channels=[TICKER], callbacks={TICKER: ticker}))
f.add_feed(Binance(symbols=['BTC-USDT'], channels=[CANDLES], callbacks={CANDLES: CandleCallback(candle_callback)}))
f.run()
def main():
f = FeedHandler()
f.add_feed(
Bitmex(pairs=['XBTUSD'],
channels=[L2_BOOK],
callbacks=DeltaBook("Bitmex").L2))
f.add_feed(
Bitfinex(pairs=['BTC-USD'],
channels=[L3_BOOK],
callbacks=DeltaBook("Bitfinex-L3").L3))
f.add_feed(
Bitfinex(pairs=['BTC-USD'],
channels=[L2_BOOK],
callbacks=DeltaBook("Bitfinex-L2").L2))
f.add_feed(
Coinbase(pairs=['BTC-USD'],
channels=[L3_BOOK],
callbacks=DeltaBook("Coinbase-L3").L3))
f.add_feed(
Coinbase(pairs=['BTC-USD'],
channels=[L2_BOOK],
callbacks=DeltaBook("Coinbase-L2").L2))
f.add_feed(
Gemini(book_interval=100,
pairs=['BTC-USD'],
channels=[L2_BOOK],
callbacks=DeltaBook("Gemini").L2))
f.add_feed(
HitBTC(book_interval=100,
pairs=['BTC-USD'],
channels=[L2_BOOK],
callbacks=DeltaBook("HitBTC").L2))
f.add_feed(
Poloniex(book_interval=100,
pairs=['BTC-USDT'],
channels=[L2_BOOK],
callbacks=DeltaBook("Poloniex").L2))
f.add_feed(
Kraken(book_interval=100,
pairs=['BTC-USD'],
channels=[L2_BOOK],
callbacks=DeltaBook("Kraken").L2))
f.add_feed(
OKCoin(book_interval=100,
pairs=['BTC-USD'],
channels=[L2_BOOK],
callbacks=DeltaBook("OKCoin").L2))
f.add_feed(
Bybit(book_interval=100,
pairs=['BTC-USD'],
channels=[L2_BOOK],
callbacks=DeltaBook("Bybit").L2))
f.add_feed(
Binance(book_interval=30,
pairs=['BTC-USDT'],
channels=[L2_BOOK],
callbacks=DeltaBook("Binance").L2))
f.run()
def main():
f = FeedHandler()
f.add_feed(Bitmex(channels=[TRADES, FUNDING, OPEN_INTEREST], symbols=['BTC-USD'], callbacks={TRADES: TradeRedis(), FUNDING: FundingRedis(), OPEN_INTEREST: OpenInterestRedis()}))
f.add_feed(Bitfinex(channels=[TRADES], symbols=['BTC-USD'], callbacks={TRADES: TradeRedis()}))
f.add_feed(Coinbase(channels=[TRADES], symbols=['BTC-USD'], callbacks={TRADES: TradeRedis()}))
f.add_feed(Coinbase(channels=[L2_BOOK], symbols=['BTC-USD'], callbacks={BOOK_DELTA: BookDeltaStream(), L2_BOOK: BookStream()}))
f.add_feed(Gemini(symbols=['BTC-USD'], callbacks={TRADES: TradeRedis()}))
f.add_feed(Binance(candle_closed_only=True, symbols=['BTC-USDT'], channels=[CANDLES], callbacks={CANDLES: CandlesRedis(score_key='start')}))
f.run()
def streaming_ticker():
f = FeedHandler()
f.add_feed(
Binance(pairs=['BTC-USDT'],
channels=[TRADES, TICKER],
callbacks={
TICKER: TickerCallback(ticker),
TRADES: TradeCallback(trade)
}))
f.run()
def main():
f = FeedHandler()
f.add_feed(
Bybit(channels=[
CANDLES, TRADES, OPEN_INTEREST, INDEX, LIQUIDATIONS, FUNDING
],
symbols=['BTC-USD-PERP'],
callbacks={
FUNDING: FundingPostgres(**postgres_cfg),
LIQUIDATIONS: LiquidationsPostgres(**postgres_cfg),
CANDLES: CandlesPostgres(**postgres_cfg),
OPEN_INTEREST: OpenInterestPostgres(**postgres_cfg),
INDEX: IndexPostgres(**postgres_cfg),
TRADES: TradePostgres(**postgres_cfg)
}))
f.add_feed(
Binance(channels=[TICKER],
symbols=['BTC-USDT'],
callbacks={TICKER: TickerPostgres(**postgres_cfg)}))
f.add_feed(
Binance(channels=[L2_BOOK],
symbols=['LTC-USDT'],
callbacks={
L2_BOOK:
BookPostgres(snapshot_interval=100,
table='l2_book',
**postgres_cfg)
}))
# The following feed shows custom_columns and uses the custom_candles table example from the bottom of postgres_tables.sql. Obviously you can swap this out for your own table layout, just update the dictionary above
f.add_feed(
Binance(channels=[CANDLES],
symbols=['FTM-USDT'],
callbacks={
CANDLES:
CandlesPostgres(**postgres_cfg,
custom_columns=column_mappings,
table='custom_candles')
}))
f.run()
def main():
config = {'log': {'filename': 'demo.log', 'level': 'DEBUG', 'disabled': False}}
# the config will be automatically passed into any exchanges set up by string. Instantiated exchange objects would need to pass the config in manually.
f = FeedHandler(config=config)
f.add_feed(FMFW(symbols=['BTC-USDT'], channels=[CANDLES, L2_BOOK, TRADES, TICKER], callbacks={CANDLES: candle_callback, TICKER: ticker, L2_BOOK: book, TRADES: trade}))
f.add_feed(AscendEX(symbols=['XRP-USDT'], channels=[L2_BOOK, TRADES], callbacks={L2_BOOK: book, TRADES: trade}))
f.add_feed(Bequant(symbols=['BTC-USDT'], channels=[L2_BOOK], callbacks={L2_BOOK: book, TRADES: trade, TICKER: ticker, CANDLES: candle_callback}))
pairs = Binance.symbols()[:1]
f.add_feed(Binance(symbols=pairs, channels=[L2_BOOK], callbacks={L2_BOOK: book, CANDLES: candle_callback, TRADES: trade, TICKER: ticker}))
pairs = BinanceFutures.symbols()[:30]
f.add_feed(BinanceFutures(symbols=pairs, channels=[TRADES, OPEN_INTEREST, FUNDING, LIQUIDATIONS], callbacks={TRADES: trade, OPEN_INTEREST: oi, FUNDING: funding, LIQUIDATIONS: liquidations}))
f.add_feed(BinanceUS(symbols=BinanceUS.symbols()[:2], channels=[TRADES, L2_BOOK], callbacks={L2_BOOK: book, TRADES: trade}))
f.add_feed(Bitfinex(symbols=['BTC-USDT'], channels=[L3_BOOK], callbacks={L3_BOOK: book, TICKER: ticker, TRADES: trade}))
f.add_feed(Bitflyer(symbols=['BTC-JPY'], channels=[TICKER, TRADES, L2_BOOK], callbacks={L2_BOOK: book, TICKER: ticker, TRADES: trade}))
f.add_feed(Bithumb(symbols=['BTC-KRW'], channels=[TRADES], callbacks={TRADES: trade}))
f.add_feed(Bitmex(timeout=5000, symbols=Bitmex.symbols(), channels=[LIQUIDATIONS], callbacks={LIQUIDATIONS: liquidations, OPEN_INTEREST: oi, FUNDING: funding}))
f.add_feed(Bitstamp(channels=[L2_BOOK, TRADES], symbols=['BTC-USD'], callbacks={L2_BOOK: book, TRADES: trade}))
f.add_feed(Bittrex(subscription={L2_BOOK: ['BTC-USDT'], CANDLES: ['BTC-USDT', 'ETH-USDT'], TRADES: ['ETH-USDT', 'BTC-USDT'], TICKER: ['ETH-USDT']}, callbacks={CANDLES: candle_callback, L2_BOOK: book, TICKER: ticker, TRADES: trade}))
f.add_feed(BLOCKCHAIN, subscription={L2_BOOK: ['BTC-USD'], TRADES: Blockchain.symbols()}, callbacks={L2_BOOK: book, TRADES: trade})
f.add_feed(Bybit(symbols=['BTC-USDT-PERP', 'BTC-USD-PERP'], channels=[INDEX, FUNDING, OPEN_INTEREST], callbacks={OPEN_INTEREST: oi, INDEX: index, FUNDING: funding}))
f.add_feed(Bybit(candle_closed_only=True, symbols=['BTC-USDT-PERP', 'BTC-USD-PERP'], channels=[CANDLES, TRADES, L2_BOOK], callbacks={CANDLES: candle_callback, TRADES: trade, L2_BOOK: book}))
f.add_feed(Coinbase(subscription={L2_BOOK: ['BTC-USD'], TRADES: ['BTC-USD'], TICKER: ['BTC-USD']}, callbacks={TRADES: trade, L2_BOOK: book, TICKER: ticker}))
f.add_feed(Coinbase(subscription={L3_BOOK: ['LTC-USD']}, callbacks={L3_BOOK: book}))
f.add_feed(Deribit(symbols=['BTC-USD-PERP'], channels=[L2_BOOK, TRADES, TICKER, FUNDING, OPEN_INTEREST, LIQUIDATIONS], callbacks={TRADES: trade, L2_BOOK: book, TICKER: ticker, OPEN_INTEREST: oi, FUNDING: funding, LIQUIDATIONS: liquidations}))
f.add_feed(dYdX(symbols=dYdX.symbols(), channels=[L2_BOOK, TRADES], callbacks={TRADES: trade, L2_BOOK: book}))
f.add_feed(FTX(checksum_validation=True, symbols=['ALGO-USD-PERP'], channels=[TICKER, TRADES, L2_BOOK, LIQUIDATIONS, OPEN_INTEREST, FUNDING], callbacks={TICKER: ticker, TRADES: trade, OPEN_INTEREST: oi, FUNDING: funding, LIQUIDATIONS: liquidations, L2_BOOK: book}))
f.add_feed(Gateio(symbols=['BTC-USDT', 'ETH-USDT'], channels=[L2_BOOK, CANDLES, TRADES, TICKER], callbacks={CANDLES: candle_callback, L2_BOOK: book, TRADES: trade, TICKER: ticker}))
f.add_feed(GEMINI, subscription={L2_BOOK: ['BTC-USD', 'ETH-USD'], TRADES: ['ETH-USD', 'BTC-USD']}, callbacks={TRADES: trade, L2_BOOK: book})
f.add_feed(HitBTC(channels=[TRADES], symbols=['BTC-USDT'], callbacks={TRADES: trade}))
f.add_feed(Huobi(symbols=['BTC-USDT'], channels=[CANDLES, TRADES, L2_BOOK], callbacks={TRADES: trade, L2_BOOK: book, CANDLES: candle_callback}))
f.add_feed(HuobiDM(subscription={L2_BOOK: HuobiDM.symbols()[:2], TRADES: HuobiDM.symbols()[:10]}, callbacks={TRADES: trade, L2_BOOK: book}))
pairs = ['BTC-USD-PERP', 'ETH-USD-PERP', 'EOS-USD-PERP', 'BCH-USD-PERP', 'BSV-USD-PERP', 'LTC-USD-PERP']
f.add_feed(HuobiSwap(symbols=pairs, channels=[TRADES, L2_BOOK, FUNDING], callbacks={FUNDING: funding, TRADES: trade, L2_BOOK: book}))
f.add_feed(KrakenFutures(symbols=KrakenFutures.symbols(), channels=[L2_BOOK, TICKER, TRADES, OPEN_INTEREST, FUNDING], callbacks={L2_BOOK: book, FUNDING: funding, OPEN_INTEREST: oi, TRADES: trade, TICKER: ticker}))
f.add_feed(Kraken(config='config.yaml', checksum_validation=True, subscription={L2_BOOK: ['BTC-USD'], TRADES: ['BTC-USD'], CANDLES: ['BTC-USD'], TICKER: ['ETH-USD']}, callbacks={L2_BOOK: book, CANDLES: candle_callback, TRADES: trade, TICKER: ticker}))
f.add_feed(KuCoin(symbols=['BTC-USDT', 'ETH-USDT'], channels=[TICKER, TRADES, CANDLES], callbacks={CANDLES: candle_callback, TICKER: ticker, TRADES: trade}))
f.add_feed(OKX(checksum_validation=True, symbols=['BTC-USDT-PERP'], channels=[TRADES, TICKER, FUNDING, OPEN_INTEREST, LIQUIDATIONS, L2_BOOK], callbacks={L2_BOOK: book, TICKER: ticker, LIQUIDATIONS: liquidations, FUNDING: funding, OPEN_INTEREST: oi, TRADES: trade}))
f.add_feed(OKCoin(checksum_validation=True, symbols=['BTC-USD'], channels=[TRADES, TICKER, L2_BOOK], callbacks={L2_BOOK: book, TICKER: ticker, TRADES: trade}))
f.add_feed(Phemex(symbols=[Symbol('BTC', 'USD', type=PERPETUAL)], channels=[L2_BOOK, CANDLES, TRADES], callbacks={TRADES: trade, L2_BOOK: book, CANDLES: candle_callback}))
f.add_feed(Poloniex(symbols=['BTC-USDT'], channels=[TICKER, TRADES], callbacks={TICKER: ticker, TRADES: trade}))
f.add_feed(Poloniex(subscription={TRADES: ['DOGE-BTC'], L2_BOOK: ['LTC-BTC']}, callbacks={TRADES: trade, L2_BOOK: book}))
f.add_feed(Probit(subscription={TRADES: ['BTC-USDT'], L2_BOOK: ['BTC-USDT']}, callbacks={TRADES: trade, L2_BOOK: book}))
f.add_feed(Upbit(subscription={TRADES: ['BTC-USDT'], L2_BOOK: ['BTC-USDT']}, callbacks={TRADES: trade, L2_BOOK: book}))
f.add_feed(CryptoDotCom(symbols=['BTC-USDT'], channels=[L2_BOOK, TICKER, CANDLES, TRADES], callbacks={TRADES: trade, CANDLES: candle_callback, TICKER: ticker, L2_BOOK: book}))
f.add_feed(Delta(symbols=['BTC-USDT', 'BTC-USDT-PERP'], channels=[L2_BOOK, TRADES, CANDLES], callbacks={TRADES: trade, CANDLES: candle_callback, L2_BOOK: book}))
f.add_feed(BitDotCom(config="config.yaml", sandbox=True, symbols=['BTC-USDT', 'BTC-USD-PERP'], channels=[TICKER, TRADES, L2_BOOK], callbacks={TRADES: trade, L2_BOOK: book, TICKER: ticker}))
f.add_feed(Bitget(config='config.yaml', symbols=['BTC-USD-PERP', 'BTC-USDT-PERP', 'BTC-USDT'], channels=[L2_BOOK, TICKER, CANDLES, TRADES], callbacks={CANDLES: candle_callback, TRADES: trade, L2_BOOK: book, TICKER: ticker}))
f.add_feed(IndependentReserve(symbols=['BTC-USD'], channels=[L3_BOOK, TRADES], callbacks={TRADES: trade, L3_BOOK: book}))
f.run()
def main():
path_to_config = 'config.yaml'
binance = Binance(config=path_to_config,
subscription={
BALANCES: [],
ORDER_INFO: []
},
timeout=-1,
callbacks={
BALANCES: balance,
ORDER_INFO: order_info
})
binance_delivery = BinanceDelivery(config=path_to_config,
subscription={
BALANCES: [],
POSITIONS: [],
ORDER_INFO: []
},
timeout=-1,
callbacks={
BALANCES: balance,
POSITIONS: position,
ORDER_INFO: order_info
})
binance_futures = BinanceFutures(config=path_to_config,
subscription={
BALANCES: [],
POSITIONS: [],
ORDER_INFO: []
},
timeout=-1,
callbacks={
BALANCES: balance,
POSITIONS: position,
ORDER_INFO: order_info
})
print(binance._generate_token())
print(binance_delivery._generate_token())
print(binance_futures._generate_token())
f = FeedHandler()
f.add_feed(binance)
f.add_feed(binance_delivery)
f.add_feed(binance_futures)
f.run()
def main():
f = FeedHandler()
# Note: EXX is extremely unreliable - sometimes a connection can take many many retries
# f.add_feed(EXX(pairs=['BTC-USDT'], channels=[L2_BOOK, TRADES], callbacks={L2_BOOK: BookCallback(book), TRADES: TradeCallback(trade)}))
f.add_feed(Gateio(pairs=['BTC-USDT', 'ETH-USDT'], channels=[TRADES, L2_BOOK], callbacks={TRADES: TradeCallback(trade), L2_BOOK: BookCallback(book)}))
f.add_feed(Binance(pairs=['BTC-USDT'], channels=[TRADES, TICKER, L2_BOOK], callbacks={L2_BOOK: BookCallback(book), TRADES: TradeCallback(trade), TICKER: TickerCallback(ticker)}))
f.add_feed(COINBASE, pairs=['BTC-USD'], channels=[TICKER], callbacks={TICKER: TickerCallback(ticker)})
f.add_feed(Coinbase(pairs=['BTC-USD'], channels=[TRADES], callbacks={TRADES: TradeCallback(trade)}))
f.add_feed(Coinbase(config={L2_BOOK: ['BTC-USD', 'ETH-USD'], TRADES: ['ETH-USD', 'BTC-USD']}, callbacks={TRADES: TradeCallback(trade), L2_BOOK: BookCallback(book)}))
f.add_feed(Bitfinex(pairs=['BTC-USD'], channels=[L2_BOOK], callbacks={L2_BOOK: BookCallback(book)}))
f.add_feed(Poloniex(pairs=['BTC-USDT', 'BTC-USDC'], channels=[TICKER, TRADES, VOLUME], callbacks={VOLUME: volume, TICKER: TickerCallback(ticker), TRADES: TradeCallback(trade)}))
f.add_feed(Poloniex(config={TRADES: ['DOGE-BTC', 'ETH-BTC'], TICKER: ['ETH-BTC'], L2_BOOK: ['LTC-BTC']}, callbacks={TRADES: TradeCallback(trade), TICKER: TickerCallback(ticker), L2_BOOK: BookCallback(book)}))
f.add_feed(GEMINI, config={L2_BOOK: ['BTC-USD', 'ETH-USD'], TRADES: ['ETH-USD', 'BTC-USD']}, callbacks={TRADES: TradeCallback(trade), L2_BOOK: BookCallback(book)})
f.add_feed(HitBTC(channels=[TRADES], pairs=['BTC-USD'], callbacks={TRADES: TradeCallback(trade)}))
f.add_feed(HitBTC(channels=[L2_BOOK], pairs=['BTC-USD'], callbacks={L2_BOOK: BookCallback(book)}))
f.add_feed(Bitstamp(channels=[L2_BOOK, TRADES], pairs=['BTC-USD'], callbacks={L2_BOOK: BookCallback(book), TRADES: TradeCallback(trade)}))
bitmex_symbols = Bitmex.info()['pairs']
f.add_feed(Bitmex(channels=[OPEN_INTEREST], pairs=['XBTUSD'], callbacks={OPEN_INTEREST: oi}))
f.add_feed(Bitmex(channels=[TRADES], pairs=bitmex_symbols, callbacks={TRADES: TradeCallback(trade)}))
f.add_feed(Bitmex(pairs=['XBTUSD'], channels=[FUNDING, TRADES], callbacks={FUNDING: FundingCallback(funding), TRADES: TradeCallback(trade)}))
f.add_feed(Bitfinex(pairs=['BTC'], channels=[FUNDING], callbacks={FUNDING: FundingCallback(funding)}))
f.add_feed(Bitmex(pairs=['XBTUSD'], channels=[L2_BOOK], callbacks={L2_BOOK: BookCallback(book)}))
f.add_feed(Kraken(checksum_validation=True, config={L2_BOOK: ['BTC-USD'], TRADES: ['BTC-USD'], TICKER: ['ETH-USD']}, callbacks={L2_BOOK: book, TRADES: TradeCallback(trade), TICKER: TickerCallback(ticker)}))
config = {TRADES: ['BTC-USDT', 'ETH-USDT'], L2_BOOK: ['BTC-USDT']}
f.add_feed(Huobi(config=config, callbacks={TRADES: TradeCallback(trade), L2_BOOK: BookCallback(book)}))
config = {L2_BOOK: ['BTC_CQ', 'BTC_NQ']}
f.add_feed(HuobiDM(config=config, callbacks={TRADES: TradeCallback(trade), L2_BOOK: BookCallback(book)}))
pairs = ['BTC-USD', 'ETH-USD', 'EOS-USD', 'BCH-USD', 'BSV-USD', 'LTC-USD']
f.add_feed(HuobiSwap(pairs=pairs, channels=[TRADES, L2_BOOK, FUNDING], callbacks={FUNDING: funding, TRADES: TradeCallback(trade), L2_BOOK: BookCallback(book)}))
f.add_feed(OKCoin(pairs=['BTC-USD'], channels=[L2_BOOK], callbacks={L2_BOOK: BookCallback(book)}))
f.add_feed(OKEx(pairs=['BTC-USDT'], channels=[TRADES], callbacks={TRADES: TradeCallback(trade)}))
f.add_feed(Bittrex(config={TRADES: ['BTC-USD'], TICKER: ['ETH-USD'], L2_BOOK: ['BTC-USDT']}, callbacks={L2_BOOK: BookCallback(book), TICKER: TickerCallback(ticker), TRADES: TradeCallback(trade)}))
f.add_feed(FTX(pairs=['ADA-PERP', 'ALGO-PERP', 'ALT-PERP', 'ATOM-PERP', 'BCH-PERP', 'BNB-PERP', 'BSV-PERP', 'BTC-PERP', 'BTMX-PERP', 'DOGE-PERP', 'DRGN-PERP', 'EOS-PERP', 'ETC-PERP'], channels=[TICKER], callbacks={TICKER: ticker, TRADES: TradeCallback(trade)}))
f.add_feed(Bybit(pairs=['BTC-USD'], channels=[FUTURES_INDEX], callbacks={OPEN_INTEREST: OpenInterestCallback(oi), FUTURES_INDEX: FuturesIndexCallback(futures_index)}))
f.add_feed(BLOCKCHAIN, pairs=['BTC-USD', 'ETH-USD'], channels=[L2_BOOK, TRADES], callbacks={
L2_BOOK: BookCallback(book),
TRADES: trade,
})
f.run()
def main():
f = FeedHandler()
f.add_feed(Bitmex(max_depth=100, book_interval=1000, pairs=['XBTUSD'], channels=[L2_BOOK], callbacks=DeltaBook("Bitmex").L2))
f.add_feed(Bitfinex(pairs=['BTC-USD'], channels=[L3_BOOK], callbacks=DeltaBook("Bitfinex-L3").L3))
f.add_feed(Bitfinex(max_depth=100, pairs=['BTC-USD'], channels=[L2_BOOK], callbacks=DeltaBook("Bitfinex-L2").L2))
f.add_feed(Coinbase(pairs=['BTC-USD'], channels=[L3_BOOK], callbacks=DeltaBook("Coinbase-L3").L3))
f.add_feed(Coinbase(max_depth=50, pairs=['BTC-USD'], channels=[L2_BOOK], callbacks=DeltaBook("Coinbase-L2").L2))
f.add_feed(EXX(max_depth=25, book_interval=100, pairs=['BTC-USDT'], channels=[L2_BOOK], callbacks=DeltaBook("EXX").L2))
f.add_feed(Gemini(max_depth=20, book_interval=100, pairs=['BTC-USD'], channels=[L2_BOOK], callbacks=DeltaBook("Gemini").L2))
f.add_feed(HitBTC(max_depth=10, book_interval=100, pairs=['BTC-USD'], channels=[L2_BOOK], callbacks=DeltaBook("HitBTC").L2))
f.add_feed(Poloniex(max_depth=10, book_interval=100, pairs=['BTC-USDT'], channels=[L2_BOOK], callbacks=DeltaBook("Poloniex").L2))
f.add_feed(Kraken(max_depth=10, book_interval=100, pairs=['BTC-USD'], channels=[L2_BOOK], callbacks=DeltaBook("Kraken").L2))
f.add_feed(OKCoin(max_depth=100, book_interval=100, pairs=['BTC-USD'], channels=[L2_BOOK], callbacks=DeltaBook("OKCoin").L2))
f.add_feed(Bybit(max_depth=100, book_interval=100, pairs=['BTC-USD'], channels=[L2_BOOK], callbacks=DeltaBook("Bybit").L2))
f.add_feed(Binance(max_depth=100, book_interval=30, pairs=['BTC-USDT'], channels=[L2_BOOK], callbacks=DeltaBook("Binance").L2))
f.add_feed(Bitstamp(max_depth=100, book_interval=30, pairs=['BTC-USD'], channels=[L2_BOOK], callbacks=DeltaBook("Bitstamp").L2))
f.add_feed(Bittrex(book_interval=100, pairs=['BTC-USD'], channels=[L2_BOOK], callbacks=DeltaBook("Bittrex").L2))
f.add_feed(Upbit(book_interval=2, pairs=['BTC-KRW'], channels=[L2_BOOK], callbacks=DeltaBook("Upbit").L2))
f.add_feed(Blockchain(pairs=['BTC-USD'], channels=[L2_BOOK], callbacks=DeltaBook("Blockchain-L2").L2))
f.run()
def main():
path_to_config = 'config.yaml'
binance = Binance(config=path_to_config)
print(binance.balances_sync())
print(binance.orders_sync())
order = binance.place_order_sync('BTC-USDT', SELL, LIMIT, 0.002, 80000, time_in_force=GOOD_TIL_CANCELED, test=False)
print(binance.orders_sync(symbol='BTC-USDT'))
print(order)
print(binance.cancel_order_sync(order['orderId'], symbol='BTC-USDT'))
print(binance.orders_sync(symbol='BTC-USDT'))
binance_futures = BinanceFutures(config=path_to_config)
print(binance_futures.balances_sync())
print(binance_futures.orders_sync())
print(binance_futures.positions_sync())
order = binance_futures.place_order_sync('ETH-USDT-PERP', SELL, LIMIT, 20, 5000, time_in_force=GOOD_TIL_CANCELED)
print(binance_futures.orders_sync(symbol='BTC-USDT-PERP'))
print(binance_futures.orders_sync(symbol='ETH-USDT-PERP'))
print(order)
print(binance_futures.cancel_order_sync(order['orderId'], symbol='ETH-USDT-PERP'))
print(binance_futures.orders_sync(symbol='ETH-USDT-PERP'))
binance_delivery = BinanceDelivery(config=path_to_config)
print(binance_delivery.balances_sync())
print(binance_delivery.orders_sync())
print(binance_delivery.positions_sync())
order = binance_delivery.place_order_sync('ETH-USD-PERP', SELL, LIMIT, 0.05, 5000, time_in_force=GOOD_TIL_CANCELED, test=False)
print(binance_delivery.orders_sync(symbol='BTC-USDT-PERP'))
print(binance_delivery.orders_sync(symbol='ETH-USDT-PERP'))
print(order)
print(binance_delivery.cancel_order_sync(order['orderId'], symbol='ETH-USDT-PERP'))
print(binance_delivery.orders_sync(symbol='ETH-USDT-PERP'))
f = FeedHandler()
f.add_feed(BinanceDelivery(max_depth=3, symbols=[info['symbols'][-1]],
channels=[L2_BOOK, TRADES, TICKER],
callbacks={L2_BOOK: abook, TRADES: trades, TICKER: ticker}))
f.run()
''' Copyright (C) 2017-2022 Bryant Moscon - [email protected] Please see the LICENSE file for the terms and conditions associated with this software. ''' import asyncio from decimal import Decimal from cryptofeed.defines import BINANCE, BINANCE_DELIVERY, BINANCE_FUTURES, BUY, SELL from cryptofeed.exchanges import BinanceFutures, BinanceDelivery, Binance from cryptofeed.types import Candle b = Binance() bd = BinanceDelivery() bf = BinanceFutures() def teardown_module(module): try: loop = asyncio.get_running_loop() except RuntimeError: loop = asyncio.new_event_loop() loop.run_until_complete(b.shutdown()) loop.run_until_complete(bf.shutdown()) loop.run_until_complete(bd.shutdown()) class TestBinanceRest: def test_trade(self):
kraken_syms = [
'ADA-BTC', 'DASH-BTC', 'ETH-BTC', 'EOS-BTC', 'LTC-BTC', 'XLM-BTC',
'XMR-BTC', 'XRP-BTC', 'ZEC-BTC', 'ADA-ETH', 'EOS-ETH', 'BTC-USD',
'ETH-USD', 'LTC-USD', 'EOS-USD'
]
bitfinex_syms = [
'ETH-BTC', 'EOS-BTC', 'LTC-BTC', 'XLM-BTC', 'XMR-BTC', 'XRP-BTC',
'ZEC-BTC', 'EOS-ETH', 'BTC-USD', 'ETH-USD', 'LTC-USD', 'EOS-USD'
]
bitstamp_syms = ['ETH-BTC', 'LTC-BTC', 'XRP-BTC']
binance_syms = [
'ADA-BTC', 'DASH-BTC', 'ETH-BTC', 'EOS-BTC', 'LTC-BTC', 'XLM-BTC',
'XMR-BTC', 'XRP-BTC', 'ZEC-BTC', 'ADA-ETH', 'EOS-ETH', 'LTC-ETH'
]
fh = FeedHandler()
fh.add_feed(
Kraken(pairs=kraken_syms,
channels=[L2_BOOK],
callbacks={L2_BOOK: BookCallback(book)}))
#fh.add_feed(Bitfinex(pairs=bitfinex_syms, channels=[L2_BOOK], callbacks={L2_BOOK: BookCallback(book)}))
#fh.add_feed(Bitstamp(pairs=bitstamp_syms, channels=[L2_BOOK], callbacks={L2_BOOK: BookCallback(book)}))
fh.add_feed(
Binance(pairs=binance_syms,
channels=[L2_BOOK],
callbacks={L2_BOOK: BookCallback(book)}))
fh.run()
def main():
f = FeedHandler()
f.add_feed(Binance(channels=[CANDLES, TRADES, TICKER], symbols=['BTC-USDT'], callbacks={CANDLES: CandlesPostgres(**postgres_cfg), TICKER: TickerPostgres(**postgres_cfg), TRADES: TradePostgres(**postgres_cfg)}))
f.run()
def main():
f = FeedHandler()
# Note: EXX is extremely unreliable - sometimes a connection can take many many retries
# f.add_feed(EXX(pairs=['BTC-USDT'], channels=[L2_BOOK, TRADES], callbacks={L2_BOOK: BookCallback(book), TRADES: TradeCallback(trade)}))
f.add_feed(
Binance(pairs=['BTC-USDT'],
channels=[TRADES, TICKER, L2_BOOK],
callbacks={
L2_BOOK: BookCallback(book),
TRADES: TradeCallback(trade),
TICKER: TickerCallback(ticker)
}))
f.add_feed(COINBASE,
pairs=['BTC-USD'],
channels=[TICKER],
callbacks={TICKER: TickerCallback(ticker)})
f.add_feed(
Coinbase(pairs=['BTC-USD'],
channels=[TRADES],
callbacks={TRADES: TradeCallback(trade)}))
f.add_feed(
Coinbase(config={
L2_BOOK: ['BTC-USD', 'ETH-USD'],
TRADES: ['ETH-USD', 'BTC-USD']
},
callbacks={
TRADES: TradeCallback(trade),
L2_BOOK: BookCallback(book)
}))
f.add_feed(
Bitfinex(pairs=['BTC-USD'],
channels=[L2_BOOK],
callbacks={L2_BOOK: BookCallback(book)}))
f.add_feed(
Poloniex(pairs=['BTC-USDT', 'BTC-USDC'],
channels=[TICKER, TRADES],
callbacks={
TICKER: TickerCallback(ticker),
TRADES: TradeCallback(trade)
}))
f.add_feed(
Poloniex(config={
TRADES: ['DOGE-BTC', 'ETH-BTC'],
TICKER: ['ETH-BTC'],
L2_BOOK: ['LTC-BTC']
},
callbacks={
TRADES: TradeCallback(trade),
TICKER: TickerCallback(ticker),
L2_BOOK: BookCallback(book)
}))
f.add_feed(GEMINI,
config={
L2_BOOK: ['BTC-USD', 'ETH-USD'],
TRADES: ['ETH-USD', 'BTC-USD']
},
callbacks={
TRADES: TradeCallback(trade),
L2_BOOK: BookCallback(book)
})
f.add_feed(
HitBTC(channels=[TRADES],
pairs=['BTC-USD'],
callbacks={TRADES: TradeCallback(trade)}))
f.add_feed(
HitBTC(channels=[L2_BOOK],
pairs=['BTC-USD'],
callbacks={L2_BOOK: BookCallback(book)}))
f.add_feed(
Bitstamp(channels=[L2_BOOK, TRADES],
pairs=['BTC-USD'],
callbacks={
L2_BOOK: BookCallback(book),
TRADES: TradeCallback(trade)
}))
bitmex_symbols = Bitmex.get_active_symbols()
f.add_feed(
Bitmex(channels=[OPEN_INTEREST],
pairs=['XBTUSD'],
callbacks={OPEN_INTEREST: oi}))
f.add_feed(
Bitmex(channels=[TRADES],
pairs=bitmex_symbols,
callbacks={TRADES: TradeCallback(trade)}))
f.add_feed(
Bitmex(pairs=['XBTUSD'],
channels=[FUNDING, TRADES],
callbacks={
FUNDING: FundingCallback(funding),
TRADES: TradeCallback(trade)
}))
f.add_feed(
Bitfinex(pairs=['BTC'],
channels=[FUNDING],
callbacks={FUNDING: FundingCallback(funding)}))
f.add_feed(
Bitmex(pairs=['XBTUSD'],
channels=[L2_BOOK],
callbacks={L2_BOOK: BookCallback(book)}))
f.add_feed(
Kraken(config={
TRADES: ['BTC-USD'],
TICKER: ['ETH-USD']
},
callbacks={
TRADES: TradeCallback(trade),
TICKER: TickerCallback(ticker)
}))
config = {TRADES: ['BTC-USDT', 'ETH-USDT'], L2_BOOK: ['BTC-USDT']}
f.add_feed(
Huobi(config=config,
callbacks={
TRADES: TradeCallback(trade),
L2_BOOK: BookCallback(book)
}))
config = {L2_BOOK: ['BTC_CQ']}
f.add_feed(
HuobiDM(config=config,
callbacks={
TRADES: TradeCallback(trade),
L2_BOOK: BookCallback(book)
}))
f.add_feed(
OKCoin(pairs=['BTC-USD'],
channels=[L2_BOOK],
callbacks={L2_BOOK: BookCallback(book)}))
f.add_feed(
OKEx(pairs=['BTC-USDT'],
channels=[TRADES],
callbacks={TRADES: TradeCallback(trade)}))
f.add_feed(
Bittrex(config={
TRADES: ['BTC-USD'],
TICKER: ['ETH-USD'],
L2_BOOK: ['BTC-USDT']
},
callbacks={
L2_BOOK: BookCallback(book),
TICKER: TickerCallback(ticker),
TRADES: TradeCallback(trade)
}))
f.add_feed(
FTX(pairs=[
'BSVDOOM-USD', 'ADA-PERP', 'ALGO-PERP', 'ALT-PERP', 'ATOM-PERP',
'BCH-PERP', 'BNB-PERP', 'BSV-PERP', 'BTC-PERP', 'BTMX-PERP',
'DOGE-PERP', 'DRGN-PERP', 'EOS-PERP', 'ETC-PERP'
],
channels=[TICKER],
callbacks={
TICKER: ticker,
TRADES: TradeCallback(trade)
}))
f.run()
def main():
try:
# p = Process(target=receiver, args=(5678,))
# p.start()
path_to_config = os.path.join(Path.home(), 'config.yaml')
f = FeedHandler()
binance_futures_symbols = defaultdict(list)
for instrument in BinanceFutures.get_instrument_objects():
binance_futures_symbols[instrument.instrument_type].append(instrument.instrument_name)
print(binance_futures_symbols)
binance_delivery_symbols = defaultdict(list)
for instrument in BinanceDelivery.get_instrument_objects():
binance_delivery_symbols[instrument.instrument_type].append(instrument.instrument_name)
print(binance_delivery_symbols)
# binance_symbols = set()
# for instrument in BinanceDelivery.get_instrument_objects():
# binance_symbols.add(instrument.base + '-USDT')
# print(binance_symbols)
binance_symbols = []
for instrument in Binance.info()['symbols']:
if instrument.endswith('-USDT'):
binance_symbols.append(instrument)
print(binance_symbols)
feeds = []
feeds.append(BinanceDelivery(candle_interval='1d', symbols=binance_delivery_symbols[PERPETUAL], channels=[FUTURES_INDEX, FUNDING, TICKER, TRADES, VOLUME], callbacks={
FUNDING: FundingZMQ(port=5678),
TICKER: TickerZMQ(port=5679),
TRADES: TradeZMQ(port=5682),
FUTURES_INDEX: FuturesIndexZMQ(port=5684),
VOLUME: VolumeZMQ(port=5685)}))
feeds.append(BinanceDelivery(candle_interval='1d', symbols=binance_delivery_symbols[FUTURE], channels=[FUTURES_INDEX, TICKER, TRADES, VOLUME], callbacks={
TICKER: TickerZMQ(port=5687),
TRADES: TradeZMQ(port=5688),
FUTURES_INDEX: FuturesIndexZMQ(port=5689),
VOLUME: VolumeZMQ(port=5690)}))
feeds.append(BinanceDelivery(config=path_to_config, channels=[USER_BALANCE, USER_POSITION], symbols=[], callbacks={
USER_BALANCE: UserBalanceZMQ(port=5691),
USER_POSITION: UserPositionZMQ(port=5692)}))
feeds.append(BinanceFutures(symbols=binance_futures_symbols[PERPETUAL], channels=[FUNDING], callbacks={FUNDING: FundingZMQ(port=5680)}))
feeds.append(Binance(symbols=list(binance_symbols), channels=[TICKER, TRADES, VOLUME], callbacks={
TICKER: TickerZMQ(port=5681),
TRADES: TradeZMQ(port=5683),
VOLUME: VolumeZMQ(port=5686)}))
feeds.append(Binance(config=path_to_config, channels=[USER_BALANCE], symbols=[], callbacks={
USER_BALANCE: UserBalanceZMQ(port=5693)}))
tasks = []
for feed in feeds:
if feed.requires_authentication:
tasks.append(do_periodically_every(0, 30, 0, feed.auth.refresh_token))
f.add_feed(feed)
f.run(tasks=tasks)
finally:
p.terminate()