def main():
try:
p = Process(target=receiver, args=(5555, ))
p.start()
f = FeedHandler()
f.add_feed(
Coinbase(channels=[L3_BOOK, TRADES],
pairs=['BTC-USD'],
callbacks={
TRADES: TradeUDP(),
L3_BOOK: BookUDP(depth=1)
}))
f.run()
finally:
p.terminate()
def main():
f = FeedHandler()
f.add_feed(
Bitmex(pairs=['XBTUSD'],
channels=[L3_BOOK],
callbacks=DeltaBook("Bitmex").L3))
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'],
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,
channels=['BTC-USDT'],
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.run()
def crawl_book_and_trade_data(symbols: List[str],
exchanges: List[str]) -> None:
postgres_cfg = get_postgres_cfg_details()
feed_handler = FeedHandler()
for exchange in exchanges:
feed_handler.add_feed(EXCHANGE_MAP[exchange](
channels=[L2_BOOK, TRADES],
symbols=symbols,
callbacks={
BOOK_DELTA: BookDeltaPostgres(**postgres_cfg),
L2_BOOK: BookPostgres(**postgres_cfg),
TRADES: TradePostgres(**postgres_cfg),
},
))
logging.info(f"{exchange} feed added.")
logging.info("Starting crawling.")
feed_handler.run()
def main():
f = FeedHandler()
#for ccypair in poloniex_trading_pairs2:f.add_feed(Poloniex(channels=[ccypair], callbacks={TICKER: TickerCallback(ticker)}))
#working
#f.add_feed(Bitfinex(pairs=['BTC-USD'], channels=[L2_BOOK, TICKER], callbacks={L2_BOOK: BookCallback(book), TICKER: TickerCallback(ticker)}))
#f.add_nbbo([Bitfinex, Gemini, HitBTC, Bitstamp], ['BTC-USD'], nbbo_ticker)
#f.add_feed(Poloniex(channels=['USDT-BTC', 'USDC-BTC','BTC-LSK'], callbacks={TICKER: TickerCallback(ticker)}))
#f.add_feed(Poloniex(channels=['USDT-BTC', 'USDC-BTC'], callbacks={L2_BOOK: BookCallback(book)}))
#f.add_feed(Poloniex(channels=['USDT-BTC', 'USDC-BTC'], 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(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(Bitstamp(channels=[L2_BOOK, TRADES], pairs=['BTC-USD'], callbacks={L2_BOOK: BookCallback(book), TRADES: TradeCallback(trade)}))
f.run()
def main():
fh = FeedHandler()
# Add futures contracts
callbacks = {TRADES: TradeCallback(trade), L2_BOOK: BookCallback(book), TRADES: trade, TICKER: TickerCallback(ticker)}
pairs = OKEx.get_active_symbols()[:5]
fh.add_feed(OKEx(pairs=pairs, channels=[TRADES, L2_BOOK, TICKER], callbacks=callbacks))
# Add swaps. Futures and swaps could be added together in one feed, but its clearer to
# add them as separate feeds.
# EOS-USD-SWAP is from the swap exchange, BTC-USDT is from spot exchage.
fh.add_feed(OKEx(pairs=['EOS-USD-SWAP', 'BTC-USDT'], channels=[L2_BOOK, TICKER, TRADES], callbacks={L2_BOOK: book, TRADES: trade, TICKER: ticker}))
# Open Interest and Funding Rates
fh.add_feed(OKEx(pairs=['EOS-USD-SWAP'], channels=[FUNDING], callbacks={FUNDING: funding}))
fh.add_feed(OKEx(pairs=pairs, channels=[OPEN_INTEREST], callbacks={OPEN_INTEREST: open_int}))
fh.run()
def main():
try:
p = Process(target=receiver, args=(5555, ))
p.start()
sleep(1)
f = FeedHandler()
f.add_feed(
Coinbase(channels=[L2_BOOK, TRADES],
symbols=['BTC-USD'],
callbacks={
TRADES: TradeSocket('udp://127.0.0.1', port=5555),
L2_BOOK: BookSocket('udp://127.0.0.1', port=5555),
}))
f.run()
finally:
p.terminate()
def main():
"""
Because periods cannot be in keys in documents in mongo, the prices in L2/L3 books
are converted to integers in the following way:
price is * 10000 and truncated
"""
f = FeedHandler()
f.add_feed(
Coinbase(channels=[TRADES, L2_BOOK],
pairs=['BTC-USD'],
callbacks={
TRADES: TradeMongo('coinbase', collection='trades'),
L2_BOOK: BookMongo('coinbase', collection='l2_book'),
BOOK_DELTA: BookDeltaMongo('coinbase',
collection='l2_book')
}))
f.run()
def main():
"""
Because periods cannot be in keys in documents in mongo, the bids and asks dictionaries
are converted to BSON. They will need to be decoded after being read
"""
f = FeedHandler()
f.add_feed(
Coinbase(max_depth=10,
channels=[L2_BOOK],
pairs=['BTC-USD'],
callbacks={
TRADES: TradeMongo('coinbase', collection='trades'),
L2_BOOK: BookMongo('coinbase', collection='l2_book'),
BOOK_DELTA: BookDeltaMongo('coinbase',
collection='l2_book')
}))
f.run()
def main():
f = FeedHandler()
f.add_feed(
Bitmex(channels=[TRADES, FUNDING],
symbols=['BTC-USD-PERP'],
callbacks={
TRADES: TradeArctic('cryptofeed-test'),
FUNDING: FundingArctic('cryptofeed-test')
}))
f.add_feed(
Bitfinex(channels=[TRADES],
symbols=['BTC-USD'],
callbacks={TRADES: TradeArctic('cryptofeed-test')}))
f.add_feed(
Coinbase(channels=[TICKER],
symbols=['BTC-USD'],
callbacks={TICKER: TickerArctic('cryptofeed-test')}))
f.run()
def main():
try:
p = Process(target=receiver, args=(5555, ))
p2 = Process(target=receiver, args=(5556, ))
p.start()
p2.start()
f = FeedHandler()
f.add_feed(
Kraken(channels=[L2_BOOK],
pairs=['ETH-USD'],
callbacks={L2_BOOK: BookZMQ(depth=1, port=5556)}))
f.run()
finally:
p.terminate()
p2.terminate()
def main():
# if you use the YAML file, pass the filename as the following:
#
# f = FeedHandler(config='path/config_example.yml')
#
# in this demo we use the dict:
f = FeedHandler(config=config)
bitmex_symbols = Bitmex.info()['symbols']
f.add_feed(Bitmex(config=config, symbols=bitmex_symbols, channels=[OPEN_INTEREST], callbacks={OPEN_INTEREST: print_all}))
f.add_feed(Bitmex(config=config, symbols=bitmex_symbols, channels=[TRADES], callbacks={TRADES: TradeCallback(print_all)}))
# When using the following no need to pass config when using 'BITMEX'
f.add_feed('BITMEX', symbols=bitmex_symbols, channels=[FUNDING], callbacks={FUNDING: FundingCallback(print_all)})
f.add_feed('BITMEX', symbols=['BTC-USD'], channels=[L2_BOOK], callbacks={L2_BOOK: BookCallback(print_all)})
f.run()
def main():
f = FeedHandler()
# due to the way the test verification works, you can only run one for the test
# f.add_feed(Bitmex(pairs=['XBTUSD'], channels=[L3_BOOK], callbacks={L3_BOOK: BookCallback(book), BOOK_DELTA: BookUpdateCallback(l3_delta)}))
# f.add_feed(Bitfinex(pairs=['BTC-USD'], channels=[L3_BOOK], callbacks={L3_BOOK: BookCallback(book), BOOK_DELTA: BookUpdateCallback(l3_delta)}))
# f.add_feed(Bitfinex(pairs=['BTC-USD'], channels=[L2_BOOK], callbacks={L2_BOOK: BookCallback(book), BOOK_DELTA: BookUpdateCallback(delta)}))
# f.add_feed(Coinbase(pairs=['BTC-USD'], channels=[L3_BOOK], callbacks={L3_BOOK: BookCallback(book), BOOK_DELTA: BookUpdateCallback(l3_delta)}))
# f.add_feed(Coinbase(pairs=['BTC-USD'], channels=[L2_BOOK], callbacks={L2_BOOK: BookCallback(book), BOOK_DELTA: BookUpdateCallback(delta)}))
# f.add_feed(Gemini(book_interval=100, pairs=['BTC-USD'], callbacks={L2_BOOK: BookCallback(book), BOOK_DELTA: BookUpdateCallback(delta)}))
# f.add_feed(HitBTC(book_interval=100, pairs=['BTC-USD'], channels=[L2_BOOK], callbacks={L2_BOOK: BookCallback(book), BOOK_DELTA: BookUpdateCallback(delta)}))
f.add_feed(
Poloniex(book_interval=100,
channels=['USDT-BTC'],
callbacks={
L2_BOOK: BookCallback(book),
BOOK_DELTA: BookUpdateCallback(delta)
}))
f.run()
def main():
f = FeedHandler(config='config.yaml')
f.add_feed(BEQUANT, channels=[TICKER], symbols=['ADA-USDT'], callbacks={TICKER: TickerCallback(ticker)})
f.add_feed(HITBTC, channels=[TICKER], symbols=['XLM-USDT'], callbacks={TICKER: TickerCallback(ticker)})
f.add_feed(BEQUANT, channels=[L2_BOOK], symbols=['ALGO-USDT'], callbacks={L2_BOOK: (book)})
f.add_feed(HITBTC, channels=[L2_BOOK], symbols=['ATOM-USDT'], callbacks={L2_BOOK: (book)})
f.add_feed(BEQUANT, channels=[CANDLES], candle_interval='30m', symbols=['ETH-USDT'], callbacks={CANDLES: candles_callback})
f.add_feed(HITBTC, channels=[CANDLES], candle_interval='30m', symbols=['NEO-USDT'], callbacks={CANDLES: candles_callback})
f.add_feed(BEQUANT, channels=[TRADES], symbols=['XLM-USDT'], callbacks={TRADES: trade})
f.add_feed(HITBTC, channels=[TRADES], symbols=['DASH-USDT'], callbacks={TRADES: trade})
# The following channels are authenticated (non public). Make sure you have set the correct privileges on your API key(s)
f.add_feed(BEQUANT, subscription={ORDER_INFO: ['BTC-USD', 'ETH-USD']}, callbacks={ORDER_INFO: order})
f.add_feed(HITBTC, subscription={ORDER_INFO: ['BTC-USDT', 'ETH-USDT']}, callbacks={ORDER_INFO: order})
f.add_feed(BEQUANT, timeout=-1, channels=[BALANCES], symbols=['XLM-USDT'], callbacks={BALANCES: BalancesCallback(balances)})
f.add_feed(HITBTC, timeout=-1, channels=[BALANCES], symbols=['ADA-USDT'], callbacks={BALANCES: BalancesCallback(balances)})
f.add_feed(BEQUANT, timeout=-1, channels=[TRANSACTIONS], symbols=['ADA-USDT'], callbacks={TRANSACTIONS: TransactionsCallback(transactions)})
f.add_feed(HITBTC, timeout=-1, channels=[TRANSACTIONS], symbols=['ADA-USDT'], callbacks={TRANSACTIONS: TransactionsCallback(transactions)})
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():
config = {
'log': {
'filename': 'redis-demo.log',
'level': 'INFO'
},
'backend_multiprocessing': True
}
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(config=config,
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():
fh = FeedHandler()
# Add futures contracts
callbacks = {
TRADES: TradeCallback(trade),
L2_BOOK: BookCallback(book),
TICKER: TickerCallback(ticker)
}
symbols = OKEx.get_active_symbols()[:5]
fh.add_feed(
OKEx(checksum_validation=True,
symbols=symbols,
channels=[TRADES, TICKER, L2_BOOK],
callbacks=callbacks))
# Add swaps. Futures and swaps could be added together in one feed, but its clearer to
# add them as separate feeds.
# EOS-USD-SWAP is from the swap exchange, BTC-USDT is from spot exchage, BTC-USD-210129-10000-C is from options
fh.add_feed(
OKEx(symbols=['EOS-USD-SWAP', 'BTC-USDT', "BTC-USD-210129-10000-C"],
channels=[L2_BOOK, TICKER, TRADES],
callbacks={
L2_BOOK: book,
TRADES: trade,
TICKER: ticker
}))
# Open Interest, Liquidations, and Funding Rates
# funding is low volume, so set timeout to -1
fh.add_feed(OKEx(symbols=['EOS-USD-SWAP'],
channels=[FUNDING, LIQUIDATIONS],
callbacks={
FUNDING: funding,
LIQUIDATIONS: liquidation
}),
timeout=-1)
fh.add_feed(
OKEx(symbols=symbols,
channels=[OPEN_INTEREST],
callbacks={OPEN_INTEREST: open_int}))
fh.run()
class FeedProcessor:
def __init__(self, hub: Hub, exchange_class: str, pair: str) -> None:
self.feed = FeedHandler()
self.publisher = Publisher(hub, prefix='feed_processor')
self.pair = pair
self._add_feed(exchange_class)
def _add_feed(self, exchange_class: str):
trades_feed = exchange_class(pairs=[self.pair],
channels=[TRADES],
callbacks={TRADES: TradeCallback(self.trade)})
self.feed.add_feed(trades_feed)
def run(self) -> None:
self.feed.run()
async def trade(self, feed, pair, order_id, timestamp, side, amount, price):
# print(f"Timestamp: {timestamp} Feed: {feed} Pair: {pair} ID: {order_id} Side: {side} Amount: {amount} Price: {price}")
trade = Trade(timestamp=timestamp, price=price, amount=amount)
self.publisher.publish([self.pair, 'new-trade'], trade)
def main():
f = FeedHandler(config="config.yaml")
f.add_feed(DERIBIT,
channels=[FILLS, ORDER_INFO],
symbols=[
"ETH-USD-PERP", "BTC-USD-PERP", "ETH-USD-22M24",
"BTC-50000-22M24-call"
],
callbacks={
FILLS: UserFillsCallback(fill),
ORDER_INFO: OrderInfoCallback(order)
},
timeout=-1)
f.add_feed(DERIBIT,
channels=[BALANCES],
symbols=["BTC", "ETH"],
callbacks={BALANCES: BalancesCallback(balance)},
timeout=-1)
f.run()
def main():
fh = FeedHandler()
config = {
OPEN_INTEREST: ['PI_XBTUSD', 'PI_ETHUSD'],
TRADES: ['PI_XBTUSD'],
TICKER: ['PI_XBTUSD', 'PI_ETHUSD'],
L2_BOOK: ['PI_XBTUSD'],
FUNDING: ['PI_XBTUSD']
}
fh.add_feed(
KrakenFutures(config=config,
callbacks={
OPEN_INTEREST: oi,
FUNDING: funding,
TICKER: TickerCallback(ticker),
TRADES: TradeCallback(trade),
L2_BOOK: BookCallback(book)
}))
fh.run()
def main():
fh = FeedHandler()
sub = {
OPEN_INTEREST: ['PI-BTC-USD', 'PI-ETH-USD'],
TRADES: ['PI-BTC-USD'],
TICKER: ['PI-BTC-USD', 'PI-ETH-USD'],
L2_BOOK: ['PI-ETH-USD', 'PI-XRP-USD'],
FUNDING: ['PI-BTC-USD']
}
fh.add_feed(
KrakenFutures(subscription=sub,
callbacks={
OPEN_INTEREST: oi,
FUNDING: funding,
TICKER: TickerCallback(ticker),
TRADES: TradeCallback(trade),
L2_BOOK: BookCallback(book)
}))
fh.run()
def main():
try:
p = Process(target=receiver, args=(5678, ))
p.start()
f = FeedHandler()
f.add_feed(
Kraken(max_depth=1,
channels=[L2_BOOK],
symbols=['ETH-USD'],
callbacks={L2_BOOK: BookZMQ(port=5678)}))
f.add_feed(
Coinbase(channels=[TICKER],
symbols=['BTC-USD'],
callbacks={TICKER: TickerZMQ(port=5678)}))
f.run()
finally:
p.terminate()
def main():
f = FeedHandler()
f.add_feed(FTX(symbols=FTX.info()['symbols'], channels=[OPEN_INTEREST, LIQUIDATIONS],
callbacks={OPEN_INTEREST: OpenInterestCallback(oi),
LIQUIDATIONS: LiquidationCallback(liquidations)}))
symbols = [s for s in BinanceFutures.info()['symbols'] if 'PINDEX' not in s]
f.add_feed(BinanceFutures(symbols=symbols, channels=[OPEN_INTEREST, LIQUIDATIONS], callbacks={OPEN_INTEREST: OpenInterestCallback(oi), LIQUIDATIONS: LiquidationCallback(liquidations)}))
f.add_feed(Deribit(symbols=['BTC-USD-PERPETUAL', 'ETH-USD-PERPETUAL'], channels=[LIQUIDATIONS, OPEN_INTEREST],
callbacks={OPEN_INTEREST: OpenInterestCallback(oi),
LIQUIDATIONS: LiquidationCallback(liquidations)}))
f.add_feed(OKEx(symbols=['BTC-USD-SWAP', 'ETH-USD-SWAP'], channels=[LIQUIDATIONS, OPEN_INTEREST],
callbacks={OPEN_INTEREST: OpenInterestCallback(oi),
LIQUIDATIONS: LiquidationCallback(liquidations)}))
f.add_feed(Bitmex(symbols=['BTC-USD', 'ETH-USD'], channels=[LIQUIDATIONS, OPEN_INTEREST],
callbacks={OPEN_INTEREST: OpenInterestCallback(oi),
LIQUIDATIONS: LiquidationCallback(liquidations)}))
f.run()
def main():
loop = asyncio.get_event_loop()
f = FeedHandler()
f.add_feed(
Coinbase(symbols=['BTC-USD'],
channels=[TRADES],
callbacks={TRADES: trade}))
f.run(start_loop=False)
loop.call_later(5, stop)
loop.run_forever()
print("\n\n******* ADDING NEW TRADING PAIR *******\n\n")
f.add_feed(
Coinbase(symbols=['ETH-USD'],
channels=[TRADES],
callbacks={TRADES: trade}))
f.run(start_loop=False)
loop.call_later(5, stop)
loop.run_forever()
def main():
f = FeedHandler()
f.add_feed(
Coinbase(channels=[L2_BOOK, TRADES],
symbols=['BTC-USD'],
callbacks={
L2_BOOK:
BookElastic('http://localhost:9200', numeric_type=float),
TRADES:
TradeElastic('http://localhost:9200', numeric_type=float)
}))
f.add_feed(
Bitmex(channels=[FUNDING],
symbols=['BTC-USD'],
callbacks={
FUNDING:
FundingElastic('http://localhost:9200', numeric_type=float)
}))
f.run()
def main():
f = FeedHandler()
# Deribit can't handle 400+ simultaneous requests, so if all
# instruments are needed they should be fed in the different calls
config = {
TRADES: ["BTC-PERPETUAL"],
TICKER: ['ETH-PERPETUAL'],
FUNDING: ['ETH-PERPETUAL']
}
f.add_feed(
Deribit(config=config,
callbacks={
FUNDING: funding,
TICKER: TickerCallback(ticker),
TRADES: TradeCallback(trade)
}))
#f.add_feed(Deribit(pairs=['BTC-PERPETUAL'], channels=[L2_BOOK], callbacks={L2_BOOK: BookCallback(book)}))
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():
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():
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=[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)}))
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(Coinbene(channels=[L2_BOOK, TRADES, TICKER], pairs=['BTC-USDT'], callbacks={L2_BOOK: BookCallback(book), TICKER: TickerCallback(ticker), 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.run()
def main():
try:
p = Process(target=receiver, args=(5555, ))
p.start()
f = FeedHandler()
f.add_feed(
Coinbase(channels=[L2_BOOK, TRADES],
pairs=['BTC-USD'],
callbacks={
TRADES:
TradeSocket('udp://127.0.0.1', port=5555),
L2_BOOK:
Throttle(BookSocket('udp://127.0.0.1',
port=5555,
depth=10),
timer=1)
}))
f.run()
finally:
p.terminate()
def main():
set_pair_separator('/')
f = FeedHandler()
f.add_feed(COINBASE,
pairs=['BTC/USD'],
channels=[TICKER],
callbacks={TICKER: TickerCallback(ticker)})
f.add_feed(
Gemini(pairs=['BTC/USD'],
channels=[TRADES],
callbacks={TRADES: TradeCallback(trade)}))
f.add_feed(
Coinbase(config={
L2_BOOK: ['ETH/USD'],
L3_BOOK: ['BTC/USD']
},
callbacks={
L3_BOOK: BookCallback(book),
L2_BOOK: BookCallback(book)
}))
f.run()
