def main():
try:
f = FeedHandler()
#f.add_feed(Kraken(max_depth=1, channels=[L2_BOOK], symbols=['ETH-USD'], callbacks={L2_BOOK: BookZMQ(port=5678)}))
f.add_feed(
Bittrex(max_depth=1,
channels=[L2_BOOK],
symbols=['BTC-USD'],
callbacks=DeltaBookZMQ("Bittrex", port=6000).L2))
f.run()
finally:
print('done!')
def main():
loop = asyncio.get_event_loop()
f = FeedHandler()
f.add_feed(Coinbase(pairs=['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(pairs=['ETH-USD'], channels=[TRADES], callbacks={TRADES: trade}))
f.run(start_loop=False)
loop.call_later(5, stop)
loop.run_forever()
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=['BTC-USDT'], callbacks={L2_BOOK: BookCallback(book), BOOK_DELTA: BookUpdateCallback(delta)}))
# f.add_feed(Kraken(book_interval=100, pairs=['BTC-USD'], channels=[L2_BOOK], callbacks={L2_BOOK: BookCallback(book), BOOK_DELTA: BookUpdateCallback(delta)}))
f.add_feed(OKCoin(book_interval=100, pairs=['BTC-USD'], channels=[L2_BOOK], callbacks={L2_BOOK: BookCallback(book), BOOK_DELTA: BookUpdateCallback(delta)}))
f.run()
def main():
fh = FeedHandler()
callbacks = {
TRADES: TradeCallback(trade),
L2_BOOK: BookCallback(book),
TICKER: TickerCallback(ticker)
}
pairs = OKEx.get_active_symbols()
fh.add_feed(
OKEx(pairs=pairs,
channels=[TRADES_FUTURES, L2_BOOK_FUTURES, TICKER_FUTURES],
callbacks=callbacks))
fh.run()
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():
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'], OPEN_INTEREST: ['ETH-PERPETUAL']}
#f.add_feed(Deribit(config=config, callbacks={OPEN_INTEREST: oi, FUNDING: funding, TICKER: TickerCallback(ticker), TRADES: TradeCallback(trade)}))
f.add_feed(
Deribit(pairs=['BTC-PERPETUAL'],
channels=[L2_BOOK],
callbacks={L2_BOOK: BookCallback(book)}))
#f.add_feed(Deribit(pairs=['BTC-26JUN20', 'BTC-25SEP20-11000-P'], channels=[TICKER], callbacks={TICKER: TickerCallback(ticker)}))
f.run()
def main():
ftx = Rest(config='config.yaml', subaccount='subaccount')['ftx']
print(ftx.ticker('ETH-USD'))
print(ftx.orders(symbol='USDT-USD'))
f = FeedHandler(config="config.yaml")
f.add_feed(
FTX(config="config.yaml",
subaccount='subaccount',
symbols=['BTC-USD', 'BCH-USD', 'USDT-USD'],
channels=[TRADES, USER_FILLS, ORDER_INFO],
callbacks={
TRADES: TradeCallback(trade),
USER_FILLS: fill,
ORDER_INFO: order
}))
f.run()
def main():
try:
p = Process(target=receiver, args=(5678, ))
p.start()
f = FeedHandler()
f.add_feed(
Kraken(channels=[L2_BOOK],
pairs=['ETH-USD'],
callbacks={L2_BOOK: BookZMQ(depth=1, port=5678)}))
f.run()
finally:
p.terminate()
def main():
config = {'log': {'filename': 'gateio.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)
pairs = list(gateio_symbols().keys())
f.add_feed(
Gateio(symbols=pairs,
channels=[L2_BOOK],
callbacks={L2_BOOK: BookCallback(book)}))
# f.add_feed(Gateio(symbols=['BTC-USDT', 'ETH-USDT', 'ETH-BTC', 'ZKS-ETH', 'ZKS-USDT'], channels=[L2_BOOK], callbacks={L2_BOOK: BookCallback(book)}))
# huobi_pairs = list(huobi_us_symbols().keys())
# f.add_feed(Huobi(symbols=huobi_pairs, channels=[L2_BOOK], callbacks={L2_BOOK: BookCallback(book)}))
f.run()
def main():
f = FeedHandler()
configured = []
print("Querying exchange metadata")
for exchange_string, exchange_class in EXCHANGE_MAP.items():
if LIQUIDATIONS in exchange_class.info()['channels']['websocket']:
configured.append(exchange_string)
symbols = [
sym for sym in exchange_class.symbols() if 'PINDEX' not in sym
]
f.add_feed(
exchange_class(subscription={LIQUIDATIONS: symbols},
callbacks={LIQUIDATIONS: liquidations}))
print("Starting feedhandler for exchanges:", ', '.join(configured))
f.run()
def main():
ftx = FTX(config='config.yaml', subaccount='subaccount')
print(ftx.ticker_sync('ETH-USD'))
print(ftx.orders_sync(symbol='USDT-USD'))
f = FeedHandler(config="config.yaml")
f.add_feed(
FTX(config="config.yaml",
subaccount='subaccount',
symbols=['BTC-USD', 'BCH-USD', 'USDT-USD'],
channels=[TRADES, FILLS, ORDER_INFO],
callbacks={
TRADES: trade,
FILLS: fill,
ORDER_INFO: order
}))
f.run()
def main():
f = FeedHandler()
f.add_feed(
FTX(channels=[ORDER_INFO, FILLS],
callbacks={
ORDER_INFO: OrderInfoCallback(order_info),
FILLS: FillsCallback(fills)
},
config={
'ftx': {
'key_id': os.environ['key'],
'key_secret': os.environ['secret'],
'subaccount': 'm1'
}
}))
f.run()
def main():
f = FeedHandler()
f.add_feed(Bitmex(channels=[FUNDING, L2_BOOK], symbols=['BTC-USD-PERP'], callbacks={FUNDING: FundingQuest(host=QUEST_HOST, port=QUEST_PORT), L2_BOOK: BookQuest(host=QUEST_HOST, port=QUEST_PORT)}))
f.add_feed(Coinbase(channels=[TRADES], symbols=['BTC-USD'], callbacks={TRADES: TradeQuest(host=QUEST_HOST, port=QUEST_PORT)}))
f.add_feed(Coinbase(channels=[L2_BOOK], symbols=['BTC-USD'], callbacks={L2_BOOK: BookQuest(host=QUEST_HOST, port=QUEST_PORT)}))
f.add_feed(Coinbase(channels=[TICKER], symbols=['BTC-USD'], callbacks={TICKER: TickerQuest(host=QUEST_HOST, port=QUEST_PORT)}))
f.add_feed(Binance(candle_closed_only=False, channels=[CANDLES], symbols=['BTC-USDT'], callbacks={CANDLES: CandlesQuest(host=QUEST_HOST, port=QUEST_PORT)}))
f.run()
def main():
f = FeedHandler()
f.add_feed(Bitmex(channels=[TRADES, FUNDING], pairs=['XBTUSD'], callbacks={TRADES: TradeRedis(), FUNDING: FundingRedis()}))
f.add_feed(Bitfinex(channels=[TRADES], pairs=['BTC-USD'], callbacks={TRADES: TradeRedis()}))
f.add_feed(Coinbase(channels=[TRADES], pairs=['BTC-USD'], callbacks={TRADES: TradeRedis()}))
f.add_feed(Coinbase(channels=[L2_BOOK], pairs=['BTC-USD'], callbacks={L2_BOOK: BookRedis(depth=10)}))
f.add_feed(Gemini(pairs=['BTC-USD'], callbacks={TRADES: TradeRedis()}))
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():
"""
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, TRADES, TICKER],
symbols=['BTC-USD'],
callbacks={
TRADES: TradeMongo('coinbase', collection='trades'),
L2_BOOK: BookMongo('coinbase', collection='l2_book'),
TICKER: TickerMongo('coinbase', collection='ticker')
}))
f.run()
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(config="config.yaml")
all_subscription = get_new_subscription()
for key, value in other_subscription.items():
all_subscription[key].update(value)
print(all_subscription)
deribit = Deribit(config="config.yaml",
max_depth=1,
subscription=all_subscription,
callbacks=callbacks)
f.add_feed(deribit)
f.run(start_loop=True,
tasks=[
do_periodically_at(
8, 1, 1,
functools.partial(subscribe_to_new_subscription, deribit))
])
def main():
fh = FeedHandler()
config = {
TRADES: ['PI_XBTUSD'],
TICKER: ['PI_XBTUSD', 'PI_ETHUSD'],
L2_BOOK: ['PI_XBTUSD']
}
fh.add_feed(
KrakenFutures(config=config,
callbacks={
TICKER: TickerCallback(ticker),
TRADES: TradeCallback(trade),
L2_BOOK: BookCallback(book)
}))
fh.run()
def main():
try:
p = Process(target=receiver, args=(5672, ))
p.start()
f = FeedHandler()
f.add_feed(
Kraken(max_depth=2,
channels=[L2_BOOK],
pairs=['BTC-USD', 'ETH-USD'],
callbacks={L2_BOOK: BookRabbit()}))
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():
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():
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()
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():
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()
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():
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():
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():
f = FeedHandler()
f.add_feed(
Bitmex(channels=[FUNDING, L3_BOOK],
pairs=['XBTUSD'],
callbacks={
FUNDING:
FundingInflux('http://localhost:8086', 'example'),
L3_BOOK:
BookInflux('http://localhost:8086', 'example', depth=10)
}))
f.add_feed(
Coinbase(channels=[TRADES],
pairs=['BTC-USD'],
callbacks={
TRADES: TradeInflux('http://localhost:8086', 'example')
}))
f.add_feed(
Coinbase(channels=[L2_BOOK],
pairs=['BTC-USD'],
callbacks={
L2_BOOK:
BookInflux('http://localhost:8086', 'example', depth=10)
}))
f.run()
