ccxt 4.2.30__py2.py3-none-any.whl → 4.2.34__py2.py3-none-any.whl

ccxt/pro/blockchaincom.py

@@ -107,7 +107,7 @@ class blockchaincom(ccxt.async_support.blockchaincom):
         #
         event = self.safe_string(message, 'event')
         if event == 'subscribed':
-            return message
+            return
         result = {'info': message}
         balances = self.safe_value(message, 'balances', [])
         for i in range(0, len(balances)):
@@ -172,10 +172,9 @@ class blockchaincom(ccxt.async_support.blockchaincom):
         #     }
         #
         event = self.safe_string(message, 'event')
-        if event == 'subscribed':
-            return message
-        elif event == 'rejected':
-            raise ExchangeError(self.id + ' ' + self.json(message))
+        if event == 'rejected':
+            jsonMessage = self.json(message)
+            raise ExchangeError(self.id + ' ' + jsonMessage)
         elif event == 'updated':
             marketId = self.safe_string(message, 'symbol')
             symbol = self.safe_symbol(marketId, None, '-')
@@ -192,7 +191,7 @@ class blockchaincom(ccxt.async_support.blockchaincom):
                 self.ohlcvs[symbol][timeframe] = stored
             stored.append(ohlcv)
             client.resolve(stored, messageHash)
-        else:
+        elif event != 'subscribed':
             raise NotSupported(self.id + ' ' + self.json(message))
 
     async def watch_ticker(self, symbol: str, params={}) -> Ticker:
@@ -251,7 +250,7 @@ class blockchaincom(ccxt.async_support.blockchaincom):
         symbol = market['symbol']
         ticker = None
         if event == 'subscribed':
-            return message
+            return
         elif event == 'snapshot':
             ticker = self.parse_ticker(message, market)
         elif event == 'updated':
@@ -345,7 +344,7 @@ class blockchaincom(ccxt.async_support.blockchaincom):
         #
         event = self.safe_string(message, 'event')
         if event != 'updated':
-            return message
+            return
         marketId = self.safe_string(message, 'symbol')
         symbol = self.safe_symbol(marketId)
         market = self.safe_market(marketId)
@@ -500,7 +499,7 @@ class blockchaincom(ccxt.async_support.blockchaincom):
             limit = self.safe_integer(self.options, 'ordersLimit', 1000)
             self.orders = ArrayCacheBySymbolById(limit)
         if event == 'subscribed':
-            return message
+            return
         elif event == 'rejected':
             raise ExchangeError(self.id + ' ' + self.json(message))
         elif event == 'snapshot':
@@ -662,25 +661,25 @@ class blockchaincom(ccxt.async_support.blockchaincom):
         messageHash = 'orderbook:' + symbol + ':' + type
         datetime = self.safe_string(message, 'timestamp')
         timestamp = self.parse8601(datetime)
-        storedOrderBook = self.safe_value(self.orderbooks, symbol)
-        if storedOrderBook is None:
-            storedOrderBook = self.counted_order_book({})
-            self.orderbooks[symbol] = storedOrderBook
+        orderbook = self.safe_value(self.orderbooks, symbol)
+        if orderbook is None:
+            orderbook = self.counted_order_book({})
+            self.orderbooks[symbol] = orderbook
         if event == 'subscribed':
-            return message
+            return
         elif event == 'snapshot':
             snapshot = self.parse_order_book(message, symbol, timestamp, 'bids', 'asks', 'px', 'qty', 'num')
-            storedOrderBook.reset(snapshot)
+            orderbook.reset(snapshot)
         elif event == 'updated':
             asks = self.safe_value(message, 'asks', [])
             bids = self.safe_value(message, 'bids', [])
-            self.handle_deltas(storedOrderBook['asks'], asks)
-            self.handle_deltas(storedOrderBook['bids'], bids)
-            storedOrderBook['timestamp'] = timestamp
-            storedOrderBook['datetime'] = datetime
+            self.handle_deltas(orderbook['asks'], asks)
+            self.handle_deltas(orderbook['bids'], bids)
+            orderbook['timestamp'] = timestamp
+            orderbook['datetime'] = datetime
         else:
             raise NotSupported(self.id + ' watchOrderBook() does not support ' + event + ' yet')
-        client.resolve(storedOrderBook, messageHash)
+        client.resolve(orderbook, messageHash)
 
     def handle_delta(self, bookside, delta):
         bookArray = self.parse_bid_ask(delta, 'px', 'qty', 'num')
@@ -717,7 +716,8 @@ class blockchaincom(ccxt.async_support.blockchaincom):
         }
         handler = self.safe_value(handlers, channel)
         if handler is not None:
-            return handler(client, message)
+            handler(client, message)
+            return
         raise NotSupported(self.id + ' received an unsupported message: ' + self.json(message))
 
     def handle_authentication_message(self, client: Client, message):
@@ -736,7 +736,7 @@ class blockchaincom(ccxt.async_support.blockchaincom):
         if future is not None:
             future.resolve(True)
 
-    def authenticate(self, params={}):
+    async def authenticate(self, params={}):
         url = self.urls['api']['ws']
         client = self.client(url)
         messageHash = 'authenticated'

ccxt/pro/bybit.py

@@ -853,7 +853,7 @@ class bybit(ccxt.async_support.bybit):
         """
         :see: https://bybit-exchange.github.io/docs/v5/websocket/private/position
         watch all open positions
-        :param str[]|None symbols: list of unified market symbols
+        :param str[] [symbols]: list of unified market symbols
         :param dict params: extra parameters specific to the exchange API endpoint
         :returns dict[]: a list of `position structure <https://docs.ccxt.com/en/latest/manual.html#position-structure>`
         """
@@ -883,7 +883,7 @@ class bybit(ccxt.async_support.bybit):
 
     def set_positions_cache(self, client: Client, symbols: Strings = None):
         if self.positions is not None:
-            return self.positions
+            return
         fetchPositionsSnapshot = self.handle_option('watchPositions', 'fetchPositionsSnapshot', True)
         if fetchPositionsSnapshot:
             messageHash = 'fetchPositionsSnapshot'
@@ -1002,7 +1002,7 @@ class bybit(ccxt.async_support.bybit):
             limit = orders.getLimit(symbol, limit)
         return self.filter_by_symbol_since_limit(orders, symbol, since, limit, True)
 
-    def handle_order(self, client: Client, message, subscription=None):
+    def handle_order(self, client: Client, message):
         #
         #     spot
         #     {
@@ -1532,7 +1532,7 @@ class bybit(ccxt.async_support.bybit):
         authenticated = self.safe_value(client.subscriptions, messageHash)
         if authenticated is None:
             expiresInt = self.milliseconds() + 10000
-            expires = str(expiresInt)
+            expires = self.number_to_string(expiresInt)
             path = 'GET/realtime'
             auth = path + expires
             signature = self.hmac(self.encode(auth), self.encode(self.secret), hashlib.sha256, 'hex')
@@ -1544,7 +1544,7 @@ class bybit(ccxt.async_support.bybit):
             }
             message = self.extend(request, params)
             self.watch(url, messageHash, message, messageHash)
-        return future
+        return await future
 
     def handle_error_message(self, client: Client, message):
         #

ccxt/pro/cex.py

@@ -912,15 +912,15 @@ class cex(ccxt.async_support.cex):
         messageHash = 'orderbook:' + symbol
         timestamp = self.safe_integer_2(data, 'timestamp_ms', 'timestamp')
         incrementalId = self.safe_number(data, 'id')
-        storedOrderBook = self.order_book({})
+        orderbook = self.order_book({})
         snapshot = self.parse_order_book(data, symbol, timestamp, 'bids', 'asks')
         snapshot['nonce'] = incrementalId
-        storedOrderBook.reset(snapshot)
+        orderbook.reset(snapshot)
         self.options['orderbook'][symbol] = {
             'incrementalId': incrementalId,
         }
-        self.orderbooks[symbol] = storedOrderBook
-        client.resolve(storedOrderBook, messageHash)
+        self.orderbooks[symbol] = orderbook
+        client.resolve(orderbook, messageHash)
 
     def pair_to_symbol(self, pair):
         parts = pair.split(':')
@@ -1355,7 +1355,8 @@ class cex(ccxt.async_support.cex):
     def handle_message(self, client: Client, message):
         ok = self.safe_string(message, 'ok')
         if ok == 'error':
-            return self.handle_error_message(client, message)
+            self.handle_error_message(client, message)
+            return
         event = self.safe_string(message, 'e')
         handlers = {
             'auth': self.handle_authentication_message,
@@ -1382,8 +1383,7 @@ class cex(ccxt.async_support.cex):
         }
         handler = self.safe_value(handlers, event)
         if handler is not None:
-            return handler(client, message)
-        return message
+            handler(client, message)
 
     def handle_authentication_message(self, client: Client, message):
         #

ccxt/pro/coinbase.py

@@ -437,7 +437,8 @@ class coinbase(ccxt.async_support.coinbase):
             side = self.safe_string(self.options['sides'], sideId)
             price = self.safe_number(trade, 'price_level')
             amount = self.safe_number(trade, 'new_quantity')
-            orderbook[side].store(price, amount)
+            orderbookSide = orderbook[side]
+            orderbookSide.store(price, amount)
 
     def handle_order_book(self, client, message):
         #
@@ -525,4 +526,4 @@ class coinbase(ccxt.async_support.coinbase):
             errorMessage = self.safe_string(message, 'message')
             raise ExchangeError(errorMessage)
         method = self.safe_value(methods, channel)
-        return method(client, message)
+        method(client, message)

ccxt/pro/coinbasepro.py

@@ -892,4 +892,4 @@ class coinbasepro(ccxt.async_support.coinbasepro):
                 else:
                     self.handle_trade(client, message)
         else:
-            return method(client, message)
+            method(client, message)

ccxt/pro/coinex.py

@@ -630,26 +630,26 @@ class coinex(ccxt.async_support.coinex):
         #
         params = self.safe_value(message, 'params', [])
         fullOrderBook = self.safe_value(params, 0)
-        orderBook = self.safe_value(params, 1)
+        orderbook = self.safe_value(params, 1)
         marketId = self.safe_string(params, 2)
         defaultType = self.safe_string(self.options, 'defaultType')
         market = self.safe_market(marketId, None, None, defaultType)
         symbol = market['symbol']
         name = 'orderbook'
         messageHash = name + ':' + symbol
-        timestamp = self.safe_integer(orderBook, 'time')
+        timestamp = self.safe_integer(orderbook, 'time')
         currentOrderBook = self.safe_value(self.orderbooks, symbol)
         if fullOrderBook:
-            snapshot = self.parse_order_book(orderBook, symbol, timestamp)
+            snapshot = self.parse_order_book(orderbook, symbol, timestamp)
             if currentOrderBook is None:
-                orderBook = self.order_book(snapshot)
-                self.orderbooks[symbol] = orderBook
+                orderbook = self.order_book(snapshot)
+                self.orderbooks[symbol] = orderbook
             else:
-                orderBook = self.orderbooks[symbol]
-                orderBook.reset(snapshot)
+                orderbook = self.orderbooks[symbol]
+                orderbook.reset(snapshot)
         else:
-            asks = self.safe_value(orderBook, 'asks', [])
-            bids = self.safe_value(orderBook, 'bids', [])
+            asks = self.safe_value(orderbook, 'asks', [])
+            bids = self.safe_value(orderbook, 'bids', [])
             self.handle_deltas(currentOrderBook['asks'], asks)
             self.handle_deltas(currentOrderBook['bids'], bids)
             currentOrderBook['nonce'] = timestamp
@@ -962,8 +962,9 @@ class coinex(ccxt.async_support.coinex):
         }
         handler = self.safe_value(handlers, method)
         if handler is not None:
-            return handler(client, message)
-        return self.handle_subscription_status(client, message)
+            handler(client, message)
+            return
+        self.handle_subscription_status(client, message)
 
     def handle_authentication_message(self, client: Client, message):
         #
@@ -987,13 +988,14 @@ class coinex(ccxt.async_support.coinex):
         if subscription is not None:
             futureIndex = self.safe_string(subscription, 'future')
             if futureIndex == 'ohlcv':
-                return self.handle_ohlcv(client, message)
+                self.handle_ohlcv(client, message)
+                return
             future = self.safe_value(client.futures, futureIndex)
             if future is not None:
                 future.resolve(True)
             del client.subscriptions[id]
 
-    def authenticate(self, params={}):
+    async def authenticate(self, params={}):
         type = None
         type, params = self.handle_market_type_and_params('authenticate', None, params)
         url = self.urls['api']['ws'][type]

ccxt/pro/currencycom.py

@@ -517,9 +517,10 @@ class currencycom(ccxt.async_support.currencycom):
                         }
                         method = self.safe_value(methods, subscriptionDestination)
                         if method is None:
-                            return message
+                            return
                         else:
-                            return method(client, message, subscription)
+                            method(client, message, subscription)
+                            return
         destination = self.safe_string(message, 'destination')
         if destination is not None:
             methods = {
@@ -529,7 +530,5 @@ class currencycom(ccxt.async_support.currencycom):
                 'ping': self.handle_pong,
             }
             method = self.safe_value(methods, destination)
-            if method is None:
-                return message
-            else:
-                return method(client, message)
+            if method is not None:
+                method(client, message)

ccxt/pro/deribit.py

@@ -728,13 +728,13 @@ class deribit(ccxt.async_support.deribit):
             }
             handler = self.safe_value(handlers, channelId)
             if handler is not None:
-                return handler(client, message)
+                handler(client, message)
+                return
             raise NotSupported(self.id + ' no handler found for self message ' + self.json(message))
         result = self.safe_value(message, 'result', {})
         accessToken = self.safe_string(result, 'access_token')
         if accessToken is not None:
-            return self.handle_authentication_message(client, message)
-        return message
+            self.handle_authentication_message(client, message)
 
     def handle_authentication_message(self, client: Client, message):
         #
@@ -758,7 +758,7 @@ class deribit(ccxt.async_support.deribit):
         client.resolve(message, messageHash)
         return message
 
-    def authenticate(self, params={}):
+    async def authenticate(self, params={}):
         url = self.urls['api']['ws']
         client = self.client(url)
         time = self.milliseconds()

ccxt/pro/exmo.py

@@ -495,22 +495,22 @@ class exmo(ccxt.async_support.exmo):
         orderBook = self.safe_value(message, 'data', {})
         messageHash = 'orderbook:' + symbol
         timestamp = self.safe_integer(message, 'ts')
-        storedOrderBook = self.safe_value(self.orderbooks, symbol)
-        if storedOrderBook is None:
-            storedOrderBook = self.order_book({})
-            self.orderbooks[symbol] = storedOrderBook
+        orderbook = self.safe_value(self.orderbooks, symbol)
+        if orderbook is None:
+            orderbook = self.order_book({})
+            self.orderbooks[symbol] = orderbook
         event = self.safe_string(message, 'event')
         if event == 'snapshot':
             snapshot = self.parse_order_book(orderBook, symbol, timestamp, 'bid', 'ask')
-            storedOrderBook.reset(snapshot)
+            orderbook.reset(snapshot)
         else:
             asks = self.safe_value(orderBook, 'ask', [])
             bids = self.safe_value(orderBook, 'bid', [])
-            self.handle_deltas(storedOrderBook['asks'], asks)
-            self.handle_deltas(storedOrderBook['bids'], bids)
-            storedOrderBook['timestamp'] = timestamp
-            storedOrderBook['datetime'] = self.iso8601(timestamp)
-        client.resolve(storedOrderBook, messageHash)
+            self.handle_deltas(orderbook['asks'], asks)
+            self.handle_deltas(orderbook['bids'], bids)
+            orderbook['timestamp'] = timestamp
+            orderbook['datetime'] = self.iso8601(timestamp)
+        client.resolve(orderbook, messageHash)
 
     def handle_delta(self, bookside, delta):
         bidAsk = self.parse_bid_ask(delta, 0, 1)
@@ -544,7 +544,8 @@ class exmo(ccxt.async_support.exmo):
         }
         eventHandler = self.safe_value(events, event)
         if eventHandler is not None:
-            return eventHandler(client, message)
+            eventHandler(client, message)
+            return
         if (event == 'update') or (event == 'snapshot'):
             topic = self.safe_string(message, 'topic')
             if topic is not None:
@@ -565,7 +566,8 @@ class exmo(ccxt.async_support.exmo):
                 }
                 handler = self.safe_value(handlers, channel)
                 if handler is not None:
-                    return handler(client, message)
+                    handler(client, message)
+                    return
         raise NotSupported(self.id + ' received an unsupported message: ' + self.json(message))
 
     def handle_subscribed(self, client: Client, message):
@@ -603,7 +605,7 @@ class exmo(ccxt.async_support.exmo):
         messageHash = 'authenticated'
         client.resolve(message, messageHash)
 
-    def authenticate(self, params={}):
+    async def authenticate(self, params={}):
         messageHash = 'authenticated'
         type, query = self.handle_market_type_and_params('authenticate', None, params)
         url = self.urls['api']['ws'][type]

ccxt/pro/gate.py

@@ -211,7 +211,7 @@ class gate(ccxt.async_support.gate):
                 # max limit is 100
                 subscription = client.subscriptions[messageHash]
                 limit = self.safe_integer(subscription, 'limit')
-                self.spawn(self.load_order_book, client, messageHash, symbol, limit)
+                self.spawn(self.load_order_book, client, messageHash, symbol, limit, {})  # needed for c#, number of args needs to match
             storedOrderBook.cache.append(delta)
             return
         elif nonce >= deltaEnd:

ccxt/pro/gemini.py

@@ -568,7 +568,8 @@ class gemini(ccxt.async_support.gemini):
         #
         isArray = isinstance(message, list)
         if isArray:
-            return self.handle_order(client, message)
+            self.handle_order(client, message)
+            return
         reason = self.safe_string(message, 'reason')
         if reason == 'error':
             self.handle_error(client, message)
@@ -580,7 +581,8 @@ class gemini(ccxt.async_support.gemini):
         }
         type = self.safe_string(message, 'type', '')
         if type.find('candles') >= 0:
-            return self.handle_ohlcv(client, message)
+            self.handle_ohlcv(client, message)
+            return
         method = self.safe_value(methods, type)
         if method is not None:
             method(client, message)

ccxt/pro/hitbtc.py

@@ -121,7 +121,7 @@ class hitbtc(ccxt.async_support.hitbtc):
             #
         return future
 
-    async def subscribe_public(self, name: str, symbols: Strings = None, params={}):
+    async def subscribe_public(self, name: str, messageHashPrefix: str, symbols: Strings = None, params={}):
         """
          * @ignore
         :param str name: websocket endpoint name
@@ -130,7 +130,7 @@ class hitbtc(ccxt.async_support.hitbtc):
         """
         await self.load_markets()
         url = self.urls['api']['ws']['public']
-        messageHash = name
+        messageHash = messageHashPrefix
         if symbols is not None:
             messageHash = messageHash + '::' + ','.join(symbols)
         subscribe = {
@@ -215,7 +215,7 @@ class hitbtc(ccxt.async_support.hitbtc):
                 'symbols': [market['id']],
             },
         }
-        orderbook = await self.subscribe_public(name, [symbol], self.deep_extend(request, params))
+        orderbook = await self.subscribe_public(name, name, [symbol], self.deep_extend(request, params))
         return orderbook.limit()
 
     def handle_order_book(self, client: Client, message):
@@ -303,7 +303,7 @@ class hitbtc(ccxt.async_support.hitbtc):
                 'symbols': [market['id']],
             },
         }
-        result = await self.subscribe_public(name, [symbol], self.deep_extend(request, params))
+        result = await self.subscribe_public(name, 'ticker', [symbol], self.deep_extend(request, params))
         return self.safe_value(result, symbol)
 
     async def watch_tickers(self, symbols: Strings = None, params={}) -> Tickers:
@@ -334,7 +334,7 @@ class hitbtc(ccxt.async_support.hitbtc):
                 'symbols': marketIds,
             },
         }
-        tickers = await self.subscribe_public(name, symbols, self.deep_extend(request, params))
+        tickers = await self.subscribe_public(name, 'tickers', symbols, self.deep_extend(request, params))
         if self.newUpdates:
             return tickers
         return self.filter_by_array(self.tickers, 'symbol', symbols)
@@ -391,7 +391,7 @@ class hitbtc(ccxt.async_support.hitbtc):
             newTickers[symbol] = ticker
             messageHash = channel + '::' + symbol
             client.resolve(newTickers, messageHash)
-        messageHashes = self.find_message_hashes(client, channel + '::')
+        messageHashes = self.find_message_hashes(client, 'tickers::')
         for i in range(0, len(messageHashes)):
             messageHash = messageHashes[i]
             parts = messageHash.split('::')
@@ -479,7 +479,8 @@ class hitbtc(ccxt.async_support.hitbtc):
         }
         if limit is not None:
             request['limit'] = limit
-        trades = await self.subscribe_public('trades', [symbol], self.deep_extend(request, params))
+        name = 'trades'
+        trades = await self.subscribe_public(name, name, [symbol], self.deep_extend(request, params))
         if self.newUpdates:
             limit = trades.getLimit(symbol, limit)
         return self.filter_by_since_limit(trades, since, limit, 'timestamp')
@@ -600,7 +601,7 @@ class hitbtc(ccxt.async_support.hitbtc):
         }
         if limit is not None:
             request['params']['limit'] = limit
-        ohlcv = await self.subscribe_public(name, [symbol], self.deep_extend(request, params))
+        ohlcv = await self.subscribe_public(name, name, [symbol], self.deep_extend(request, params))
         if self.newUpdates:
             limit = ohlcv.getLimit(symbol, limit)
         return self.filter_by_since_limit(ohlcv, since, limit, 0)
@@ -940,7 +941,7 @@ class hitbtc(ccxt.async_support.hitbtc):
         }
         return await self.subscribe_private(name, None, self.extend(request, params))
 
-    async def create_order_ws(self, symbol: str, type: OrderType, side: OrderSide, amount, price=None, params={}) -> Order:
+    async def create_order_ws(self, symbol: str, type: OrderType, side: OrderSide, amount: float, price: float = None, params={}) -> Order:
         """
         create a trade order
         :see: https://api.hitbtc.com/#create-new-spot-order

ccxt/pro/hollaex.py

@@ -213,7 +213,7 @@ class hollaex(ccxt.async_support.hollaex):
         # when the user does not have any trades yet
         dataLength = len(rawTrades)
         if dataLength == 0:
-            return 0
+            return
         if self.myTrades is None:
             limit = self.safe_integer(self.options, 'tradesLimit', 1000)
             self.myTrades = ArrayCache(limit)
@@ -319,7 +319,7 @@ class hollaex(ccxt.async_support.hollaex):
         # usually the first message is an empty array
         dataLength = len(data)
         if dataLength == 0:
-            return 0
+            return
         if self.orders is None:
             limit = self.safe_integer(self.options, 'ordersLimit', 1000)
             self.orders = ArrayCacheBySymbolById(limit)

ccxt/pro/htx.py

@@ -452,6 +452,7 @@ class htx(ccxt.async_support.htx):
         except Exception as e:
             del client.subscriptions[messageHash]
             client.reject(e, messageHash)
+        return None
 
     def handle_delta(self, bookside, delta):
         price = self.safe_float(delta, 0)
@@ -1581,11 +1582,11 @@ class htx(ccxt.async_support.htx):
         if subscription is not None:
             method = self.safe_value(subscription, 'method')
             if method is not None:
-                return method(client, message, subscription)
+                method(client, message, subscription)
+                return
             # clean up
             if id in client.subscriptions:
                 del client.subscriptions[id]
-        return message
 
     def handle_system_status(self, client: Client, message):
         #
@@ -1694,10 +1695,9 @@ class htx(ccxt.async_support.htx):
                 'kline': self.handle_ohlcv,
             }
             method = self.safe_value(methods, methodName)
-            if method is None:
-                return message
-            else:
-                return method(client, message)
+            if method is not None:
+                method(client, message)
+                return
         # private spot subjects
         privateParts = ch.split('#')
         privateType = self.safe_string(privateParts, 0, '')

ccxt/pro/huobijp.py

@@ -350,6 +350,7 @@ class huobijp(ccxt.async_support.huobijp):
         except Exception as e:
             del client.subscriptions[messageHash]
             client.reject(e, messageHash)
+        return None
 
     def handle_delta(self, bookside, delta):
         price = self.safe_float(delta, 0)
@@ -507,10 +508,8 @@ class huobijp(ccxt.async_support.huobijp):
                 # ...
             }
             method = self.safe_value(methods, methodName)
-            if method is None:
-                return message
-            else:
-                return method(client, message)
+            if method is not None:
+                method(client, message)
 
     async def pong(self, client, message):
         #

ccxt/pro/idex.py

@@ -319,7 +319,7 @@ class idex(ccxt.async_support.idex):
                         symbol = self.safe_symbol(marketId)
                         if not (symbol in self.orderbooks):
                             orderbook = self.counted_order_book({})
-                            orderbook.cache = []
+                            # orderbook.cache = []  # cache is never used?
                             self.orderbooks[symbol] = orderbook
                         self.spawn(self.fetch_order_book_snapshot, client, symbol)
                 break

ccxt/pro/independentreserve.py

@@ -181,25 +181,25 @@ class independentreserve(ccxt.async_support.independentreserve):
         subscription = self.safe_value(client.subscriptions, messageHash, {})
         receivedSnapshot = self.safe_bool(subscription, 'receivedSnapshot', False)
         timestamp = self.safe_integer(message, 'Time')
-        storedOrderBook = self.safe_value(self.orderbooks, symbol)
-        if storedOrderBook is None:
-            storedOrderBook = self.order_book({})
-            self.orderbooks[symbol] = storedOrderBook
+        orderbook = self.safe_value(self.orderbooks, symbol)
+        if orderbook is None:
+            orderbook = self.order_book({})
+            self.orderbooks[symbol] = orderbook
         if event == 'OrderBookSnapshot':
             snapshot = self.parse_order_book(orderBook, symbol, timestamp, 'Bids', 'Offers', 'Price', 'Volume')
-            storedOrderBook.reset(snapshot)
+            orderbook.reset(snapshot)
             subscription['receivedSnapshot'] = True
         else:
             asks = self.safe_value(orderBook, 'Offers', [])
             bids = self.safe_value(orderBook, 'Bids', [])
-            self.handle_deltas(storedOrderBook['asks'], asks)
-            self.handle_deltas(storedOrderBook['bids'], bids)
-            storedOrderBook['timestamp'] = timestamp
-            storedOrderBook['datetime'] = self.iso8601(timestamp)
+            self.handle_deltas(orderbook['asks'], asks)
+            self.handle_deltas(orderbook['bids'], bids)
+            orderbook['timestamp'] = timestamp
+            orderbook['datetime'] = self.iso8601(timestamp)
         checksum = self.safe_value(self.options, 'checksum', True)
         if checksum and receivedSnapshot:
-            storedAsks = storedOrderBook['asks']
-            storedBids = storedOrderBook['bids']
+            storedAsks = orderbook['asks']
+            storedBids = orderbook['bids']
             asksLength = len(storedAsks)
             bidsLength = len(storedBids)
             payload = ''
@@ -215,7 +215,7 @@ class independentreserve(ccxt.async_support.independentreserve):
                 error = InvalidNonce(self.id + ' invalid checksum')
                 client.reject(error, messageHash)
         if receivedSnapshot:
-            client.resolve(storedOrderBook, messageHash)
+            client.resolve(orderbook, messageHash)
 
     def value_to_checksum(self, value):
         result = format(value, '.8f')
@@ -263,5 +263,6 @@ class independentreserve(ccxt.async_support.independentreserve):
         }
         handler = self.safe_value(handlers, event)
         if handler is not None:
-            return handler(client, message)
+            handler(client, message)
+            return
         raise NotSupported(self.id + ' received an unsupported message: ' + self.json(message))