def handle_trades(self, client, message, subscription): # # { # status: 'OK', # destination: 'internal.trade', # payload: { # price: 11668.55, # size: 0.001, # id: 1600300736, # ts: 1596653426822, # symbol: 'BTC/USD_LEVERAGE', # orderId: '00a02503-0079-54c4-0000-00004020163c', # clientOrderId: '00a02503-0079-54c4-0000-482f0000754f', # buyer: False # } # } # payload = self.safe_value(message, 'payload') parsed = self.handle_trade(payload) symbol = parsed['symbol'] # destination = self.safe_string(message, 'destination') destination = 'trades.subscribe' messageHash = destination + ':' + symbol stored = self.safe_value(self.trades, symbol) if stored is None: limit = self.safe_integer(self.options, 'tradesLimit', 1000) stored = ArrayCache(limit) self.trades[symbol] = stored stored.append(parsed) client.resolve(stored, messageHash)
def handle_trades(self, client, message): # {type: 'trade', # code: 'KRW-BTC', # timestamp: 1584508285812, # trade_date: '2020-03-18', # trade_time: '05:11:25', # trade_timestamp: 1584508285000, # trade_price: 6747000, # trade_volume: 0.06499468, # ask_bid: 'ASK', # prev_closing_price: 6774000, # change: 'FALL', # change_price: 27000, # sequential_id: 1584508285000002, # stream_type: 'REALTIME'} trade = self.parse_trade(message) symbol = trade['symbol'] stored = self.safe_value(self.trades, symbol) if stored is None: limit = self.safe_integer(self.options, 'tradesLimit', 1000) stored = ArrayCache(limit) self.trades[symbol] = stored stored.append(trade) marketId = self.safe_string(message, 'code') messageHash = 'trade:' + marketId client.resolve(stored, messageHash)
def handle_trade(self, client, message): # # { # event: 'trade', # timestamp: 1590779594547, # market: 'ETH-EUR', # id: '450c3298-f082-4461-9e2c-a0262cc7cc2e', # amount: '0.05026233', # price: '198.46', # side: 'buy' # } # marketId = self.safe_string(message, 'market') market = self.safe_market(marketId, None, '-') symbol = market['symbol'] name = 'trades' messageHash = name + '@' + marketId trade = self.parse_trade(message, market) array = self.safe_value(self.trades, symbol) if array is None: limit = self.safe_integer(self.options, 'tradesLimit', 1000) array = ArrayCache(limit) array.append(trade) self.trades[symbol] = array client.resolve(array, messageHash)
def handle_trades(self, client, message, subscription): # # [ # 0, # channelID # [ # price volume time side type misc # ["5541.20000", "0.15850568", "1534614057.321597", "s", "l", ""], # ["6060.00000", "0.02455000", "1534614057.324998", "b", "l", ""], # ], # "trade", # "XBT/USD" # ] # wsName = self.safe_string(message, 3) name = self.safe_string(message, 2) messageHash = name + ':' + wsName market = self.safe_value(self.options['marketsByWsName'], wsName) symbol = market['symbol'] stored = self.safe_value(self.trades, symbol) if stored is None: limit = self.safe_integer(self.options, 'tradesLimit', 1000) stored = ArrayCache(limit) self.trades[symbol] = stored trades = self.safe_value(message, 1, []) parsed = self.parse_trades(trades, market) for i in range(0, len(parsed)): stored.append(parsed[i]) client.resolve(stored, messageHash)
def handle_trades(self, client, message): # # { # sequence: 1795484727, # symbol: 'sBTCUSDT', # trades: [ # [1592891002064516600, 'Buy', 964020000000, 1431000], # [1592890978987934500, 'Sell', 963704000000, 1401800], # [1592890972918701800, 'Buy', 963938000000, 2018600], # ], # type: 'snapshot' # } # name = 'trade' marketId = self.safe_string(message, 'symbol') if marketId in self.markets_by_id: market = self.markets_by_id[marketId] symbol = market['symbol'] messageHash = name + ':' + symbol stored = self.safe_value(self.trades, symbol) if stored is None: limit = self.safe_integer(self.options, 'tradesLimit', 1000) stored = ArrayCache(limit) self.trades[symbol] = stored trades = self.safe_value(message, 'trades', []) parsed = self.parse_trades(trades, market) for i in range(0, len(parsed)): stored.append(parsed[i]) client.resolve(stored, messageHash)
def handle_trade(self, client, message): # # { # data: { # sequence: '1568787654360', # symbol: 'BTC-USDT', # side: 'buy', # size: '0.00536577', # price: '9345', # takerOrderId: '5e356c4a9f1a790008f8d921', # time: '1580559434436443257', # type: 'match', # makerOrderId: '5e356bffedf0010008fa5d7f', # tradeId: '5e356c4aeefabd62c62a1ece' # }, # subject: 'trade.l3match', # topic: '/market/match:BTC-USDT', # type: 'message' # } # data = self.safe_value(message, 'data', {}) trade = self.parse_trade(data) messageHash = self.safe_string(message, 'topic') symbol = trade['symbol'] trades = self.safe_value(self.trades, symbol) if trades is None: limit = self.safe_integer(self.options, 'tradesLimit', 1000) trades = ArrayCache(limit) self.trades[symbol] = trades trades.append(trade) client.resolve(trades, messageHash) return message
def handle_trade(self, client, message): # # { # type: 'match', # trade_id: 82047307, # maker_order_id: '0f358725-2134-435e-be11-753912a326e0', # taker_order_id: '252b7002-87a3-425c-ac73-f5b9e23f3caf', # side: 'sell', # size: '0.00513192', # price: '9314.78', # product_id: 'BTC-USD', # sequence: 12038915443, # time: '2020-01-31T20:03:41.158814Z' # } # marketId = self.safe_string(message, 'product_id') if marketId is not None: trade = self.parse_trade(message) symbol = trade['symbol'] # the exchange sends type = 'match' # but requires 'matches' upon subscribing # therefore we resolve 'matches' here instead of 'match' # type = self.safe_string(message, 'type') type = 'matches' messageHash = type + ':' + marketId array = self.safe_value(self.trades, symbol) if array is None: tradesLimit = self.safe_integer(self.options, 'tradesLimit', 1000) array = ArrayCache(tradesLimit) self.trades[symbol] = array array.append(trade) client.resolve(array, messageHash) return message
def handle_trade(self, client, message): # # { # table: 'spot/trade', # data: [ # { # side: 'buy', # trade_id: '30770973', # price: '4665.4', # size: '0.019', # instrument_id: 'BTC-USDT', # timestamp: '2020-03-16T13:41:46.526Z' # } # ] # } # table = self.safe_string(message, 'table') data = self.safe_value(message, 'data', []) tradesLimit = self.safe_integer(self.options, 'tradesLimit', 1000) for i in range(0, len(data)): trade = self.parse_trade(data[i]) symbol = trade['symbol'] marketId = self.safe_string(trade['info'], 'instrument_id') messageHash = table + ':' + marketId stored = self.safe_value(self.trades, symbol) if stored is None: stored = ArrayCache(tradesLimit) self.trades[symbol] = stored stored.append(trade) client.resolve(stored, messageHash) return message
def handle_trade(self, client, message): # # { # data: { # buy_order_id: 1207733769326592, # amount_str: "0.14406384", # timestamp: "1583691851", # microtimestamp: "1583691851934000", # id: 106833903, # amount: 0.14406384, # sell_order_id: 1207733765476352, # price_str: "8302.92", # type: 0, # price: 8302.92 # }, # event: "trade", # channel: "live_trades_btcusd" # } # # the trade streams push raw trade information in real-time # each trade has a unique buyer and seller channel = self.safe_string(message, 'channel') data = self.safe_value(message, 'data') subscription = self.safe_value(client.subscriptions, channel) symbol = self.safe_string(subscription, 'symbol') market = self.market(symbol) trade = self.parse_trade(data, market) array = self.safe_value(self.trades, symbol) if array is None: limit = self.safe_integer(self.options, 'tradesLimit', 1000) array = ArrayCache(limit) self.trades[symbol] = array array.append(trade) client.resolve(array, channel)
def handle_trades(self, client, message): # # { # deltas: [ # { # id: '5bf67885-a0a8-4c62-b73d-534e480e3332', # executedAt: '2020-10-05T23:02:17.49Z', # quantity: '0.00166790', # rate: '10763.97000000', # takerSide: 'BUY' # } # ], # sequence: 24391, # marketSymbol: 'BTC-USD' # } # deltas = self.safe_value(message, 'deltas', []) marketId = self.safe_string(message, 'marketSymbol') symbol = self.safe_symbol(marketId, None, '-') market = self.market(symbol) name = 'trade' messageHash = name + '_' + marketId stored = self.safe_value(self.trades, symbol) if stored is None: limit = self.safe_integer(self.options, 'tradesLimit', 1000) stored = ArrayCache(limit) trades = self.parse_trades(deltas, market) for i in range(0, len(trades)): stored.append(trades[i]) self.trades[symbol] = stored client.resolve(stored, messageHash)
def handle_ohlcv(self, client, message): # # { # e: 'kline', # E: 1579482921215, # s: 'ETHBTC', # k: { # t: 1579482900000, # T: 1579482959999, # s: 'ETHBTC', # i: '1m', # f: 158411535, # L: 158411550, # o: '0.01913200', # c: '0.01913500', # h: '0.01913700', # l: '0.01913200', # v: '5.08400000', # n: 16, # x: False, # q: '0.09728060', # V: '3.30200000', # Q: '0.06318500', # B: '0' # } # } # marketId = self.safe_string(message, 's') lowercaseMarketId = self.safe_string_lower(message, 's') event = self.safe_string(message, 'e') kline = self.safe_value(message, 'k') interval = self.safe_string(kline, 'i') # use a reverse lookup in a static map instead timeframe = self.find_timeframe(interval) messageHash = lowercaseMarketId + '@' + event + '_' + interval parsed = [ self.safe_integer(kline, 't'), self.safe_float(kline, 'o'), self.safe_float(kline, 'h'), self.safe_float(kline, 'l'), self.safe_float(kline, 'c'), self.safe_float(kline, 'v'), ] symbol = marketId if marketId in self.markets_by_id: market = self.markets_by_id[marketId] symbol = market['symbol'] self.ohlcvs[symbol] = self.safe_value(self.ohlcvs, symbol, {}) stored = self.safe_value(self.ohlcvs[symbol], timeframe) if stored is None: limit = self.safe_integer(self.options, 'OHLCVLimit', 1000) stored = ArrayCache(limit) self.ohlcvs[symbol][timeframe] = stored length = len(stored) if length and (parsed[0] == stored[length - 1][0]): stored[length - 1] = parsed else: stored.append(parsed) client.resolve(stored, messageHash)
def handle_ohlcv(self, client, message): # # { # jsonrpc: '2.0', # method: 'snapshotCandles', # updateCandles # params: { # data: [ # { # timestamp: '2020-04-05T00:06:00.000Z', # open: '6869.40', # close: '6867.16', # min: '6863.17', # max: '6869.4', # volume: '0.08947', # volumeQuote: '614.4195442' # }, # { # timestamp: '2020-04-05T00:07:00.000Z', # open: '6867.54', # close: '6859.26', # min: '6858.85', # max: '6867.54', # volume: '1.7766', # volumeQuote: '12191.5880395' # }, # ], # symbol: 'BTCUSD', # period: 'M1' # } # } # params = self.safe_value(message, 'params', {}) data = self.safe_value(params, 'data', []) marketId = self.safe_string(params, 'symbol') if marketId in self.markets_by_id: market = self.markets_by_id[marketId] symbol = market['symbol'] period = self.safe_string(params, 'period') timeframe = self.find_timeframe(period) messageHash = 'ohlcv:' + marketId + ':' + period limit = self.safe_integer(self.options, 'OHLCVLimit', 1000) for i in range(0, len(data)): candle = data[i] parsed = self.parse_ohlcv(candle, market) self.ohlcvs[symbol] = self.safe_value(self.ohlcvs, symbol, {}) stored = self.safe_value(self.ohlcvs[symbol], timeframe) if stored is None: stored = ArrayCache(limit) self.ohlcvs[symbol][timeframe] = stored length = len(stored) if length and parsed[0] == stored[length - 1][0]: stored[length - 1] = parsed else: stored.append(parsed) client.resolve(stored, messageHash) return message
def handle_ohlcv(self, client, message, subscription): # # [ # 216, # channelID # [ # '1574454214.962096', # Time, seconds since epoch # '1574454240.000000', # End timestamp of the interval # '0.020970', # Open price at midnight UTC # '0.020970', # Intraday high price # '0.020970', # Intraday low price # '0.020970', # Closing price at midnight UTC # '0.020970', # Volume weighted average price # '0.08636138', # Accumulated volume today # 1, # Number of trades today # ], # 'ohlc-1', # Channel Name of subscription # 'ETH/XBT', # Asset pair # ] # info = self.safe_value(subscription, 'subscription', {}) interval = self.safe_integer(info, 'interval') name = self.safe_string(info, 'name') wsName = self.safe_string(message, 3) market = self.safe_value(self.options['marketsByWsName'], wsName) symbol = market['symbol'] timeframe = self.find_timeframe(interval) duration = self.parse_timeframe(timeframe) if timeframe is not None: candle = self.safe_value(message, 1) messageHash = name + ':' + timeframe + ':' + wsName timestamp = self.safe_float(candle, 1) timestamp -= duration result = [ int(timestamp * 1000), self.safe_float(candle, 2), self.safe_float(candle, 3), self.safe_float(candle, 4), self.safe_float(candle, 5), self.safe_float(candle, 7), ] self.ohlcvs[symbol] = self.safe_value(self.ohlcvs, symbol, {}) stored = self.safe_value(self.ohlcvs[symbol], timeframe) if stored is None: limit = self.safe_integer(self.options, 'OHLCVLimit', 1000) stored = ArrayCache(limit) self.ohlcvs[symbol][timeframe] = stored length = len(stored) if length and result[0] == stored[length - 1][0]: stored[length - 1] = result else: stored.append(result) client.resolve(stored, messageHash)
def handle_trades(self, client, message, subscription): # # initial snapshot # # [ # 2, # [ # [null, 1580565020, 9374.9, 0.005], # [null, 1580565004, 9374.9, 0.005], # [null, 1580565003, 9374.9, 0.005], # ] # ] # # when a trade does not have an id yet # # # channel id, update type, seq, time, price, amount # [2, 'te', '28462857-BTCUSD', 1580565041, 9374.9, 0.005], # # when a trade already has an id # # # channel id, update type, seq, trade id, time, price, amount # [2, 'tu', '28462857-BTCUSD', 413357662, 1580565041, 9374.9, 0.005] # channel = self.safe_value(subscription, 'channel') marketId = self.safe_string(subscription, 'pair') messageHash = channel + ':' + marketId tradesLimit = self.safe_integer(self.options, 'tradesLimit', 1000) if marketId in self.markets_by_id: market = self.markets_by_id[marketId] symbol = market['symbol'] data = self.safe_value(message, 1) stored = self.safe_value(self.trades, symbol) if stored is None: stored = ArrayCache(tradesLimit) self.trades[symbol] = stored if isinstance(data, list): trades = self.parse_trades(data, market) for i in range(0, len(trades)): stored.append(trades[i]) else: second = self.safe_string(message, 1) if second != 'tu': return trade = self.parse_trade(message, market) stored.append(trade) client.resolve(stored, messageHash) return message
def handle_trades(self, client, message): # # { # jsonrpc: '2.0', # method: 'snapshotTrades', # updateTrades # params: { # data: [ # { # id: 814145791, # price: '6957.20', # quantity: '0.02779', # side: 'buy', # timestamp: '2020-04-03T10:28:20.032Z' # }, # { # id: 814145792, # price: '6957.20', # quantity: '0.12918', # side: 'buy', # timestamp: '2020-04-03T10:28:20.039Z' # }, # ], # symbol: 'BTCUSD' # } # } # params = self.safe_value(message, 'params', {}) data = self.safe_value(params, 'data', []) marketId = self.safe_string(params, 'symbol') if marketId in self.markets_by_id: market = self.markets_by_id[marketId] symbol = market['symbol'] messageHash = 'trades:' + marketId tradesLimit = self.safe_integer(self.options, 'tradesLimit', 1000) stored = self.safe_value(self.trades, symbol) if stored is None: stored = ArrayCache(tradesLimit) self.trades[symbol] = stored if isinstance(data, list): trades = self.parse_trades(data, market) for i in range(0, len(trades)): stored.append(trades[i]) else: trade = self.parse_trade(message, market) stored.append(trade) client.resolve(stored, messageHash) return message
def handle_ohlcv(self, client, message): # # { # table: "spot/candle60s", # data: [ # { # candle: [ # "2020-03-16T14:29:00.000Z", # "4948.3", # "4966.7", # "4939.1", # "4945.3", # "238.36021657" # ], # instrument_id: "BTC-USDT" # } # ] # } # table = self.safe_string(message, 'table') data = self.safe_value(message, 'data', []) parts = table.split('/') part1 = self.safe_string(parts, 1) interval = part1.replace('candle', '') interval = interval.replace('s', '') # use a reverse lookup in a static map instead timeframe = self.find_timeframe(interval) for i in range(0, len(data)): marketId = self.safe_string(data[i], 'instrument_id') if marketId in self.markets_by_id: candle = self.safe_value(data[i], 'candle') market = self.markets_by_id[marketId] symbol = market['symbol'] parsed = self.parse_ohlcv(candle, market) self.ohlcvs[symbol] = self.safe_value(self.ohlcvs, symbol, {}) stored = self.safe_value(self.ohlcvs[symbol], timeframe) if stored is None: limit = self.safe_integer(self.options, 'OHLCVLimit', 1000) stored = ArrayCache(limit) self.ohlcvs[symbol][timeframe] = stored length = len(stored) if length and parsed[0] == stored[length - 1][0]: stored[length - 1] = parsed else: stored.append(parsed) messageHash = table + ':' + marketId client.resolve(stored, messageHash)
def handle_trade(self, client, message): # the trade streams push raw trade information in real-time # each trade has a unique buyer and seller marketId = self.safe_string(message, 's') market = self.safe_market(marketId) symbol = market['symbol'] lowerCaseId = self.safe_string_lower(message, 's') event = self.safe_string(message, 'e') messageHash = lowerCaseId + '@' + event trade = self.parse_trade(message, market) array = self.safe_value(self.trades, symbol) if array is None: limit = self.safe_integer(self.options, 'tradesLimit', 1000) array = ArrayCache(limit) array.append(trade) self.trades[symbol] = array client.resolve(array, messageHash)
def handle_ohlcv(self, client, message): # # { # status: 'OK', # destination: 'ohlc.event', # payload: { # interval: 'M1', # symbol: 'BTC/USD_LEVERAGE', # t: 1596650940000, # h: 11670.05, # l: 11658.1, # o: 11668.55, # c: 11666.05 # } # } # # destination = self.safe_string(message, 'destination') destination = 'OHLCMarketData.subscribe' payload = self.safe_value(message, 'payload', {}) interval = self.safe_string(payload, 'interval') timeframe = self.find_timeframe(interval) marketId = self.safe_string(payload, 'symbol') if marketId in self.markets_by_id: market = self.markets_by_id[marketId] symbol = market['symbol'] messageHash = destination + ':' + timeframe + ':' + symbol result = [ self.safe_integer(payload, 't'), self.safe_float(payload, 'o'), self.safe_float(payload, 'h'), self.safe_float(payload, 'l'), self.safe_float(payload, 'c'), None, # no volume v in OHLCV ] self.ohlcvs[symbol] = self.safe_value(self.ohlcvs, symbol, {}) stored = self.safe_value(self.ohlcvs[symbol], timeframe) if stored is None: limit = self.safe_integer(self.options, 'OHLCVLimit', 1000) stored = ArrayCache(limit) self.ohlcvs[symbol][timeframe] = stored length = len(stored) if length and result[0] == stored[length - 1][0]: stored[length - 1] = result else: stored.append(result) client.resolve(stored, messageHash)
def handle_ohlcv(self, client, message): # {type: 'candles', # data: # {m: 'DIL-ETH', # t: 1599477340109, # i: '1m', # s: 1599477300000, # e: 1599477360000, # o: '0.09911040', # h: '0.09911040', # l: '0.09911040', # c: '0.09911040', # v: '0.15000000', # n: 1, # u: 6531}} type = self.safe_string(message, 'type') data = self.safe_value(message, 'data') marketId = self.safe_string(data, 'm') messageHash = type + ':' + marketId parsed = [ self.safe_integer(data, 's'), self.safe_float(data, 'o'), self.safe_float(data, 'h'), self.safe_float(data, 'l'), self.safe_float(data, 'c'), self.safe_float(data, 'v'), ] symbol = None if marketId in self.markets_by_id: symbol = self.markets_by_id[marketId][symbol] interval = self.safe_string(data, 'i') timeframe = self.find_timeframe(interval) # TODO: move to base class self.ohlcvs[symbol] = self.safe_value(self.ohlcvs, symbol, {}) stored = self.safe_value(self.ohlcvs[symbol], timeframe) if stored is None: limit = self.safe_integer(self.options, 'OHLCVLimit', 1000) stored = ArrayCache(limit) self.ohlcvs[symbol][timeframe] = stored length = len(stored) if length and (parsed[0] == stored[length - 1][0]): stored[length - 1] = parsed else: stored.append(parsed) client.resolve(stored, messageHash)
def handle_ohlcv(self, client, message): # # { # kline: [ # [1592905200, 60, 960688000000, 960709000000, 960709000000, 960400000000, 960400000000, 848100, 8146756046], # [1592905140, 60, 960718000000, 960716000000, 960717000000, 960560000000, 960688000000, 4284900, 41163743512], # [1592905080, 60, 960513000000, 960684000000, 960718000000, 960684000000, 960718000000, 4880500, 46887494349], # ], # sequence: 1804401474, # symbol: 'sBTCUSDT', # type: 'snapshot' # } # name = 'kline' marketId = self.safe_string(message, 'symbol') if marketId in self.markets_by_id: market = self.markets_by_id[marketId] symbol = market['symbol'] candles = self.safe_value(message, name, []) first = self.safe_value(candles, 0, []) interval = self.safe_string(first, 1) timeframe = self.find_timeframe(interval) if timeframe is not None: messageHash = name + ':' + timeframe + ':' + symbol ohlcvs = self.parse_ohlcvs(candles, market) self.ohlcvs[symbol] = self.safe_value(self.ohlcvs, symbol, {}) stored = self.safe_value(self.ohlcvs[symbol], timeframe) if stored is None: limit = self.safe_integer(self.options, 'OHLCVLimit', 1000) stored = ArrayCache(limit) self.ohlcvs[symbol][timeframe] = stored for i in range(0, len(ohlcvs)): candle = ohlcvs[i] length = len(stored) if length: if candle[0] == stored[length - 1][0]: stored[length - 1] = candle elif candle[0] > stored[length - 1][0]: stored.append(candle) else: stored.append(candle) client.resolve(stored, messageHash)
def handle_trades(self, client, message): # # [ # 'BTC_USDT', # [ # { # id: 221994511, # time: 1580311438.618647, # price: '9309', # amount: '0.0019', # type: 'sell' # }, # { # id: 221994501, # time: 1580311433.842509, # price: '9311.31', # amount: '0.01', # type: 'buy' # }, # ] # ] # params = self.safe_value(message, 'params', []) marketId = self.safe_string_lower(params, 0) market = None symbol = marketId if marketId in self.markets_by_id: market = self.markets_by_id[marketId] symbol = market['symbol'] stored = self.safe_value(self.trades, symbol) if stored is None: limit = self.safe_integer(self.options, 'tradesLimit', 1000) stored = ArrayCache(limit) self.trades[symbol] = stored trades = self.safe_value(params, 1, []) parsed = self.parse_trades(trades, market) for i in range(0, len(parsed)): stored.append(parsed[i]) methodType = message['method'] messageHash = methodType + ':' + marketId client.resolve(stored, messageHash)
def handle_ohlcv(self, client, message): # # { # ch: 'market.btcusdt.kline.1min', # ts: 1583501786794, # tick: { # id: 1583501760, # open: 9094.5, # close: 9094.51, # low: 9094.5, # high: 9094.51, # amount: 0.44639786263800907, # vol: 4059.76919054, # count: 16 # } # } # ch = self.safe_string(message, 'ch') parts = ch.split('.') marketId = self.safe_string(parts, 1) if marketId in self.markets_by_id: market = self.markets_by_id[marketId] symbol = market['symbol'] interval = self.safe_string(parts, 3) timeframe = self.find_timeframe(interval) self.ohlcvs[symbol] = self.safe_value(self.ohlcvs, symbol, {}) stored = self.safe_value(self.ohlcvs[symbol], timeframe) if stored is None: limit = self.safe_integer(self.options, 'OHLCVLimit', 1000) stored = ArrayCache(limit) self.ohlcvs[symbol][timeframe] = stored tick = self.safe_value(message, 'tick') parsed = self.parse_ohlcv(tick, market) length = len(stored) if length and parsed[0] == stored[length - 1][0]: stored[length - 1] = parsed else: stored.append(parsed) client.resolve(stored, ch)
def handle_trades(self, client, message): # # { # ch: "market.btcusdt.trade.detail", # ts: 1583495834011, # tick: { # id: 105004645372, # ts: 1583495833751, # data: [ # { # id: 1.050046453727319e+22, # ts: 1583495833751, # tradeId: 102090727790, # amount: 0.003893, # price: 9150.01, # direction: "sell" # } # ] # } # } # tick = self.safe_value(message, 'tick', {}) data = self.safe_value(tick, 'data', {}) ch = self.safe_string(message, 'ch') parts = ch.split('.') marketId = self.safe_string(parts, 1) if marketId in self.markets_by_id: market = self.markets_by_id[marketId] symbol = market['symbol'] array = self.safe_value(self.trades, symbol) if array is None: limit = self.safe_integer(self.options, 'tradesLimit', 1000) array = ArrayCache(limit) self.trades[symbol] = array for i in range(0, len(data)): trade = self.parse_trade(data[i], market) array.append(trade) client.resolve(array, ch) return message
def handle_my_trades(self, client, message): # # subscription response # # {n: 'SubscribeToTrades', o: {}} # # regular update # # { # "i": -1, # "n": "TradeEvent", # "o": { # "tradeId": 74072, # trade ID # "orderId": 453529, # order ID # "side": 2, # 1(bid), 2(ask) # "type": 1, # 1(limit), 2(market) # "baseAmount": 0.01, # filled base asset amount(in ZEC for self case) # "quoteAmount": 1, # filled quote asset amount(in KRW for self case) # "fee": 0.0004, # fee # "price": 100, # price # "isSelfTrade": False, # whether both of matching orders are yours # "occurredAt": 1603932107, # trade occurrence time # "tradingPairName": "ZEC-KRW" # order book # } # } # o = self.safe_value(message, 'o', {}) name = 'myTrades' messageHash = name trade = self.parse_trade(o) symbol = trade['symbol'] array = self.safe_value(self.myTrades, symbol) if array is None: limit = self.safe_integer(self.options, 'tradesLimit', 1000) array = ArrayCache(limit) array.append(trade) self.myTrades[symbol] = array client.resolve(array, messageHash) client.resolve(array, messageHash + ':' + symbol)
def handle_trade(self, client, message): # # { # channel: "trades", # market: "BTC-PERP", # type: "update", # data: [ # { # id: 33517246, # price: 6661.5, # size: 2.3137, # side: "sell", # liquidation: False, # time: "2020-04-02T07:45:12.011352+00:00" # } # ] # } # data = self.safe_value(message, 'data', {}) marketId = self.safe_string(message, 'market') if marketId in self.markets_by_id: market = self.markets_by_id[marketId] symbol = market['symbol'] messageHash = self.get_message_hash(message) tradesLimit = self.safe_integer(self.options, 'tradesLimit', 1000) stored = self.safe_value(self.trades, symbol) if stored is None: stored = ArrayCache(tradesLimit) self.trades[symbol] = stored if isinstance(data, list): trades = self.parse_trades(data, market) for i in range(0, len(trades)): stored.append(trades[i]) else: trade = self.parse_trade(message, market) stored.append(trade) client.resolve(stored, messageHash) return message
def handle_trade(self, client, message, subscription): # # { # messageId: 'CAAQAA==', # payload: 'eyJjcmVhdGVkX2F0IjogMTYwMTczNjI0NywgImFtb3VudCI6ICIwLjAwMjAwIiwgInByaWNlIjogIjEwNTkzLjk5MDAwMCIsICJzaWRlIjogIkJVWSIsICJwYWlyIjogIkJUQ19VU0RDIiwgInRha2VyX2ZlZSI6ICIwIiwgInRha2VyX3NpZGUiOiAiQlVZIiwgIm1ha2VyX2ZlZSI6ICIwIiwgInRha2VyIjogMjYxODU2NCwgIm1ha2VyIjogMjYxODU1N30=', # properties: {}, # publishTime: '2020-10-03T14:44:09.881Z' # } # payload = self.safe_string(message, 'payload') if payload is None: return message data = json.loads(self.base64_to_string(payload)) # # { # created_at: 1601736247, # amount: '0.00200', # price: '10593.990000', # side: 'BUY', # pair: 'BTC_USDC', # taker_fee: '0', # taker_side: 'BUY', # maker_fee: '0', # taker: 2618564, # maker: 2618557 # } # symbol = self.safe_string(subscription, 'symbol') messageHash = self.safe_string(subscription, 'messageHash') market = self.market(symbol) trade = self.parse_trade(data, market) array = self.safe_value(self.trades, symbol) if array is None: limit = self.safe_integer(self.options, 'tradesLimit', 1000) array = ArrayCache(limit) self.trades[symbol] = array array.append(trade) client.resolve(array, messageHash)
def handle_ohlcv(self, client, message): # # { # sequence: 28286, # marketSymbol: 'BTC-USD', # interval: 'MINUTE_1', # delta: { # startsAt: '2020-10-05T18:52:00Z', # open: '10706.62600000', # high: '10706.62600000', # low: '10703.25900000', # close: '10703.26000000', # volume: '0.86822264', # quoteVolume: '9292.84594774' # } # } # name = 'candle' marketId = self.safe_string(message, 'marketSymbol') symbol = self.safe_symbol(marketId, None, '-') interval = self.safe_string(message, 'interval') messageHash = name + '_' + marketId + '_' + interval timeframe = self.find_timeframe(interval) delta = self.safe_value(message, 'delta', {}) parsed = self.parse_ohlcv(delta) self.ohlcvs[symbol] = self.safe_value(self.ohlcvs, symbol, {}) stored = self.safe_value(self.ohlcvs[symbol], timeframe) if stored is None: limit = self.safe_integer(self.options, 'OHLCVLimit', 1000) stored = ArrayCache(limit) self.ohlcvs[symbol][timeframe] = stored length = len(stored) if length and (parsed[0] == stored[length - 1][0]): stored[length - 1] = parsed else: stored.append(parsed) client.resolve(stored, messageHash)
def handle_trades_message(self, client, message, market): # # { # 'M': 'BTC-ETH', # 'N': 2322248, # 'Z': [], # 'S': [ # {'TY': 0, 'R': 0.01938852, 'Q': 29.32758526}, # {'TY': 1, 'R': 0.02322822, 'Q': 0} # ], # 'f': [ # { # FI: 50365744, # OT: 'SELL', # R: 9240.432, # Q: 0.07602962, # T: 1580480744050 # } # ] # } # f = self.safe_value(message, 'f', []) trades = self.parse_trades(f, market) tradesLength = len(trades) if tradesLength > 0: symbol = market['symbol'] stored = self.safe_value(self.trades, symbol) if stored is None: limit = self.safe_integer(self.options, 'tradesLimit', 1000) stored = ArrayCache(limit) self.trades[symbol] = stored for i in range(0, len(trades)): stored.append(trades[i]) name = 'trade' messageHash = name + ':' + market['symbol'] client.resolve(stored, messageHash) return message
def handle_ohlcv(self, client, message): # # { # table: 'tradeBin1m', # action: 'partial', # keys: [], # types: { # timestamp: 'timestamp', # symbol: 'symbol', # open: 'float', # high: 'float', # low: 'float', # close: 'float', # trades: 'long', # volume: 'long', # vwap: 'float', # lastSize: 'long', # turnover: 'long', # homeNotional: 'float', # foreignNotional: 'float' # }, # foreignKeys: {symbol: 'instrument'}, # attributes: {timestamp: 'sorted', symbol: 'grouped'}, # filter: {symbol: 'XBTUSD'}, # data: [ # { # timestamp: '2020-02-03T01:13:00.000Z', # symbol: 'XBTUSD', # open: 9395, # high: 9395.5, # low: 9394.5, # close: 9395, # trades: 221, # volume: 839204, # vwap: 9394.9643, # lastSize: 1874, # turnover: 8932641535, # homeNotional: 89.32641534999999, # foreignNotional: 839204 # } # ] # } # # # { # table: 'tradeBin1m', # action: 'insert', # data: [ # { # timestamp: '2020-02-03T18:28:00.000Z', # symbol: 'XBTUSD', # open: 9256, # high: 9256.5, # low: 9256, # close: 9256, # trades: 29, # volume: 79057, # vwap: 9256.688, # lastSize: 100, # turnover: 854077082, # homeNotional: 8.540770820000002, # foreignNotional: 79057 # } # ] # } # table = self.safe_string(message, 'table') interval = table.replace('tradeBin', '') timeframe = self.find_timeframe(interval) duration = self.parse_timeframe(timeframe) candles = self.safe_value(message, 'data', []) results = {} for i in range(0, len(candles)): candle = candles[i] marketId = self.safe_string(candle, 'symbol') if marketId in self.markets_by_id: market = self.markets_by_id[marketId] symbol = market['symbol'] messageHash = table + ':' + market['id'] result = [ self.parse8601(self.safe_string(candle, 'timestamp')) - duration * 1000, self.safe_float(candle, 'open'), self.safe_float(candle, 'high'), self.safe_float(candle, 'low'), self.safe_float(candle, 'close'), self.safe_float(candle, 'volume'), ] self.ohlcvs[symbol] = self.safe_value(self.ohlcvs, symbol, {}) stored = self.safe_value(self.ohlcvs[symbol], timeframe) if stored is None: limit = self.safe_integer(self.options, 'OHLCVLimit', 1000) stored = ArrayCache(limit) self.ohlcvs[symbol][timeframe] = stored length = len(stored) if length and result[0] == stored[length - 1][0]: stored[length - 1] = result else: stored.append(result) results[messageHash] = stored messageHashes = list(results.keys()) for i in range(0, len(messageHashes)): messageHash = messageHashes[i] client.resolve(results[messageHash], messageHash)
# https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code # ---------------------------------------------------------------------------- from ccxtpro.base.cache import ArrayCache # noqa: F402 def equals(a, b): return a == b # -------------------------------------------------------------------------------------------------------------------- cache = ArrayCache(3) cache.append(1) cache.append(2) cache.append(3) cache.append(4) assert (equals(cache, [2, 3, 4])) cache.append(5) cache.append(6) cache.append(7) cache.append(8) assert (equals(cache, [6, 7, 8])) cache.clear()