ccxt 4.2.93__py2.py3-none-any.whl → 4.2.95__py2.py3-none-any.whl

ccxt/pro/krakenfutures.py

@@ -10,8 +10,8 @@ from ccxt.base.types import Balances, Int, Order, OrderBook, Position, Str, Stri
 from ccxt.async_support.base.ws.client import Client
 from typing import List
 from ccxt.base.errors import ExchangeError
-from ccxt.base.errors import ArgumentsRequired
 from ccxt.base.errors import AuthenticationError
+from ccxt.base.errors import ArgumentsRequired
 from ccxt.base.precise import Precise
 
 
@@ -32,9 +32,12 @@ class krakenfutures(ccxt.async_support.krakenfutures):
                 'fetchTradesWs': False,
                 'watchOHLCV': False,
                 'watchOrderBook': True,
+                'watchOrderBookForSymbols': True,
                 'watchTicker': True,
                 'watchTickers': True,
+                'watchBidsAsks': True,
                 'watchTrades': True,
+                'watchTradesForSymbols': True,
                 'watchBalance': True,
                 # 'watchStatus': True,  # https://docs.futures.kraken.com/#websocket-api-public-feeds-heartbeat
                 'watchOrders': True,
@@ -55,12 +58,6 @@ class krakenfutures(ccxt.async_support.krakenfutures):
                 'OHLCVLimit': 1000,
                 'connectionLimit': 100,  # https://docs.futures.kraken.com/#websocket-api-websocket-api-introduction-subscriptions-limits
                 'requestLimit': 100,  # per second
-                'watchTicker': {
-                    'method': 'ticker',  # or ticker_lite
-                },
-                'watchTickers': {
-                    'method': 'ticker',  # or ticker_lite
-                },
                 'fetchBalance': {
                     'type': None,
                 },
@@ -96,6 +93,18 @@ class krakenfutures(ccxt.async_support.krakenfutures):
             client.subscriptions[messageHash] = future
         return future
 
+    async def watch_order_book_for_symbols(self, symbols: List[str], limit: Int = None, params={}) -> OrderBook:
+        """
+        watches information on open orders with bid(buy) and ask(sell) prices, volumes and other data
+        :see: https://docs.futures.kraken.com/#websocket-api-public-feeds-challenge
+        :param str[] symbols: unified array of symbols
+        :param int [limit]: the maximum amount of order book entries to return
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: A dictionary of `order book structures <https://docs.ccxt.com/#/?id=order-book-structure>` indexed by market symbols
+        """
+        orderbook = await self.watch_multi_helper('orderbook', 'book', symbols, {'limit': limit}, params)
+        return orderbook.limit()
+
     async def subscribe_public(self, name: str, symbols: List[str], params={}):
         """
          * @ignore
@@ -156,31 +165,43 @@ class krakenfutures(ccxt.async_support.krakenfutures):
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
         """
-        options = self.safe_value(self.options, 'watchTicker')
-        method = self.safe_string(options, 'method', 'ticker')  # or ticker_lite
-        name = self.safe_string(params, 'method', method)
-        params = self.omit(params, ['method'])
-        return await self.subscribe_public(name, [symbol], params)
+        await self.load_markets()
+        symbol = self.symbol(symbol)
+        tickers = await self.watch_tickers([symbol], params)
+        return tickers[symbol]
 
     async def watch_tickers(self, symbols: Strings = None, params={}) -> Tickers:
         """
         watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
-        :see: https://docs.futures.kraken.com/#websocket-api-public-feeds-ticker-lite
+        :see: https://docs.futures.kraken.com/#websocket-api-public-feeds-ticker
         :param str symbol: unified symbol of the market to fetch the ticker for
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
         """
-        method = self.safe_string(self.options, 'watchTickerMethod', 'ticker')  # or ticker_lite
-        name = self.safe_string_2(params, 'method', 'watchTickerMethod', method)
-        params = self.omit(params, ['watchTickerMethod', 'method'])
+        await self.load_markets()
         symbols = self.market_symbols(symbols, None, False)
-        ticker = await self.subscribe_public(name, symbols, params)
+        ticker = await self.watch_multi_helper('ticker', 'ticker', symbols, None, params)
         if self.newUpdates:
-            tickers = {}
-            tickers[ticker['symbol']] = ticker
-            return tickers
+            result = {}
+            result[ticker['symbol']] = ticker
+            return result
         return self.filter_by_array(self.tickers, 'symbol', symbols)
 
+    async def watch_bids_asks(self, symbols: Strings = None, params={}) -> Tickers:
+        """
+        :see: https://docs.futures.kraken.com/#websocket-api-public-feeds-ticker-lite
+        watches best bid & ask for symbols
+        :param str[] symbols: unified symbol of the market to fetch the ticker for
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
+        """
+        ticker = await self.watch_multi_helper('bidask', 'ticker_lite', symbols, None, params)
+        if self.newUpdates:
+            result = {}
+            result[ticker['symbol']] = ticker
+            return result
+        return self.filter_by_array(self.bidsasks, 'symbol', symbols)
+
     async def watch_trades(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Trade]:
         """
         get the list of most recent trades for a particular symbol
@@ -191,11 +212,23 @@ class krakenfutures(ccxt.async_support.krakenfutures):
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict[]: a list of `trade structures <https://docs.ccxt.com/#/?id=public-trades>`
         """
-        await self.load_markets()
-        name = 'trade'
-        trades = await self.subscribe_public(name, [symbol], params)
+        return await self.watch_trades_for_symbols([symbol], since, limit, params)
+
+    async def watch_trades_for_symbols(self, symbols: List[str], since: Int = None, limit: Int = None, params={}) -> List[Trade]:
+        """
+        :see: https://docs.futures.kraken.com/#websocket-api-public-feeds-trade
+        get the list of most recent trades for a list of symbols
+        :param str[] symbols: unified symbol of the market to fetch trades for
+        :param int [since]: timestamp in ms of the earliest trade to fetch
+        :param int [limit]: the maximum amount of trades to fetch
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict[]: a list of `trade structures <https://docs.ccxt.com/#/?id=public-trades>`
+        """
+        trades = await self.watch_multi_helper('trade', 'trade', symbols, None, params)
         if self.newUpdates:
-            limit = trades.getLimit(symbol, limit)
+            first = self.safe_list(trades, 0)
+            tradeSymbol = self.safe_string(first, 'symbol')
+            limit = trades.getLimit(tradeSymbol, limit)
         return self.filter_by_since_limit(trades, since, limit, 'timestamp', True)
 
     async def watch_order_book(self, symbol: str, limit: Int = None, params={}) -> OrderBook:
@@ -207,8 +240,7 @@ class krakenfutures(ccxt.async_support.krakenfutures):
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: A dictionary of `order book structures <https://docs.ccxt.com/#/?id=order-book-structure>` indexed by market symbols
         """
-        orderbook = await self.subscribe_public('book', [symbol], params)
-        return orderbook.limit()
+        return await self.watch_order_book_for_symbols([symbol], limit, params)
 
     async def watch_positions(self, symbols: Strings = None, since: Int = None, limit: Int = None, params={}) -> List[Position]:
         """
@@ -436,7 +468,7 @@ class krakenfutures(ccxt.async_support.krakenfutures):
         if marketId is not None:
             market = self.market(marketId)
             symbol = market['symbol']
-            messageHash = 'trade:' + symbol
+            messageHash = self.get_message_hash('trade', None, symbol)
             if self.safe_list(self.trades, symbol) is None:
                 tradesLimit = self.safe_integer(self.options, 'tradesLimit', 1000)
                 self.trades[symbol] = ArrayCache(tradesLimit)
@@ -453,7 +485,6 @@ class krakenfutures(ccxt.async_support.krakenfutures):
                 trade = self.parse_ws_trade(message)
                 tradesArray.append(trade)
             client.resolve(tradesArray, messageHash)
-        return message
 
     def parse_ws_trade(self, trade, market=None):
         #
@@ -859,7 +890,15 @@ class krakenfutures(ccxt.async_support.krakenfutures):
         #        "volumeQuote": 19628180
         #    }
         #
-        # ticker_lite
+        marketId = self.safe_string(message, 'product_id')
+        if marketId is not None:
+            ticker = self.parse_ws_ticker(message)
+            symbol = ticker['symbol']
+            self.tickers[symbol] = ticker
+            messageHash = self.get_message_hash('ticker', None, symbol)
+            client.resolve(ticker, messageHash)
+
+    def handle_bid_ask(self, client: Client, message):
         #
         #    {
         #        "feed": "ticker_lite",
@@ -877,15 +916,12 @@ class krakenfutures(ccxt.async_support.krakenfutures):
         #    }
         #
         marketId = self.safe_string(message, 'product_id')
-        feed = self.safe_string(message, 'feed')
         if marketId is not None:
             ticker = self.parse_ws_ticker(message)
             symbol = ticker['symbol']
-            self.tickers[symbol] = ticker
-            messageHash = feed + ':' + symbol
+            self.bidsasks[symbol] = ticker
+            messageHash = self.get_message_hash('bidask', None, symbol)
             client.resolve(ticker, messageHash)
-        client.resolve(self.tickers, feed)
-        return message
 
     def parse_ws_ticker(self, ticker, market=None):
         #
@@ -997,14 +1033,14 @@ class krakenfutures(ccxt.async_support.krakenfutures):
         marketId = self.safe_string(message, 'product_id')
         market = self.safe_market(marketId)
         symbol = market['symbol']
-        messageHash = 'book:' + symbol
-        subscription = self.safe_value(client.subscriptions, messageHash, {})
+        messageHash = self.get_message_hash('orderbook', None, symbol)
+        subscription = self.safe_dict(client.subscriptions, messageHash, {})
         limit = self.safe_integer(subscription, 'limit')
         timestamp = self.safe_integer(message, 'timestamp')
         self.orderbooks[symbol] = self.order_book({}, limit)
         orderbook = self.orderbooks[symbol]
-        bids = self.safe_value(message, 'bids')
-        asks = self.safe_value(message, 'asks')
+        bids = self.safe_list(message, 'bids')
+        asks = self.safe_list(message, 'asks')
         for i in range(0, len(bids)):
             bid = bids[i]
             price = self.safe_number(bid, 'price')
@@ -1037,7 +1073,7 @@ class krakenfutures(ccxt.async_support.krakenfutures):
         marketId = self.safe_string(message, 'product_id')
         market = self.safe_market(marketId)
         symbol = market['symbol']
-        messageHash = 'book:' + symbol
+        messageHash = self.get_message_hash('orderbook', None, symbol)
         orderbook = self.orderbooks[symbol]
         side = self.safe_string(message, 'side')
         price = self.safe_number(message, 'price')
@@ -1353,6 +1389,35 @@ class krakenfutures(ccxt.async_support.krakenfutures):
             },
         })
 
+    async def watch_multi_helper(self, unifiedName: str, channelName: str, symbols: Strings = None, subscriptionArgs=None, params={}):
+        await self.load_markets()
+        # symbols are required
+        symbols = self.market_symbols(symbols, None, False, True, False)
+        messageHashes = []
+        for i in range(0, len(symbols)):
+            messageHashes.append(self.get_message_hash(unifiedName, None, self.symbol(symbols[i])))
+        marketIds = self.market_ids(symbols)
+        request = {
+            'event': 'subscribe',
+            'feed': channelName,
+            'product_ids': marketIds,
+        }
+        url = self.urls['api']['ws']
+        return await self.watch_multiple(url, messageHashes, self.extend(request, params), messageHashes, subscriptionArgs)
+
+    def get_message_hash(self, unifiedElementName: str, subChannelName: Str = None, symbol: Str = None):
+        # unifiedElementName can be : orderbook, trade, ticker, bidask ...
+        # subChannelName only applies to channel that needs specific variation(i.e. depth_50, depth_100..) to be selected
+        withSymbol = symbol is not None
+        messageHash = unifiedElementName
+        if not withSymbol:
+            messageHash += 's'
+        else:
+            messageHash += ':' + symbol
+        if subChannelName is not None:
+            messageHash += '#' + subChannelName
+        return messageHash
+
     def handle_error_message(self, client: Client, message):
         #
         #    {
@@ -1378,10 +1443,10 @@ class krakenfutures(ccxt.async_support.krakenfutures):
             feed = self.safe_string(message, 'feed')
             methods = {
                 'ticker': self.handle_ticker,
+                'ticker_lite': self.handle_bid_ask,
                 'trade': self.handle_trade,
                 'trade_snapshot': self.handle_trade,
                 # 'heartbeat': self.handleStatus,
-                'ticker_lite': self.handle_ticker,
                 'book': self.handle_order_book,
                 'book_snapshot': self.handle_order_book_snapshot,
                 'open_orders_verbose': self.handle_order,

ccxt/pro/kucoin.py

@@ -168,21 +168,41 @@ class kucoin(ccxt.async_support.kucoin):
 
     async def watch_tickers(self, symbols: Strings = None, params={}) -> Tickers:
         """
+        :see: https://www.kucoin.com/docs/websocket/spot-trading/public-channels/ticker
         watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for all markets of a specific list
         :param str[] symbols: unified symbol of the market to fetch the ticker for
         :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param str [params.method]: either '/market/snapshot' or '/market/ticker' default is '/market/ticker'
         :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
         """
         await self.load_markets()
         symbols = self.market_symbols(symbols)
         messageHash = 'tickers'
+        method = None
+        method, params = self.handle_option_and_params(params, 'watchTickers', 'method', '/market/ticker')
+        messageHashes = []
+        topics = []
         if symbols is not None:
-            messageHash = 'tickers::' + ','.join(symbols)
+            for i in range(0, len(symbols)):
+                symbol = symbols[i]
+                messageHashes.append('ticker:' + symbol)
+                market = self.market(symbol)
+                topics.append(method + ':' + market['id'])
         url = await self.negotiate(False)
-        topic = '/market/ticker:all'
-        tickers = await self.subscribe(url, messageHash, topic, params)
-        if self.newUpdates:
-            return tickers
+        tickers = None
+        if symbols is None:
+            allTopic = method + ':all'
+            tickers = await self.subscribe(url, messageHash, allTopic, params)
+            if self.newUpdates:
+                return tickers
+        else:
+            marketIds = self.market_ids(symbols)
+            symbolsTopic = method + ':' + ','.join(marketIds)
+            tickers = await self.subscribe_multiple(url, messageHashes, symbolsTopic, topics, params)
+            if self.newUpdates:
+                newDict = {}
+                newDict[tickers['symbol']] = tickers
+                return newDict
         return self.filter_by_array(self.tickers, 'symbol', symbols)
 
     def handle_ticker(self, client: Client, message):
@@ -262,17 +282,6 @@ class kucoin(ccxt.async_support.kucoin):
         allTickers = {}
         allTickers[symbol] = ticker
         client.resolve(allTickers, 'tickers')
-        messageHashes = self.find_message_hashes(client, 'tickers::')
-        for i in range(0, len(messageHashes)):
-            currentMessageHash = messageHashes[i]
-            parts = currentMessageHash.split('::')
-            symbolsString = parts[1]
-            symbols = symbolsString.split(',')
-            tickers = self.filter_by_array(self.tickers, 'symbol', symbols)
-            tickersSymbols = list(tickers.keys())
-            numTickers = len(tickersSymbols)
-            if numTickers > 0:
-                client.resolve(tickers, currentMessageHash)
 
     async def watch_bids_asks(self, symbols: Strings = None, params={}) -> Tickers:
         """

ccxt/pro/okcoin.py

@@ -9,8 +9,8 @@ import hashlib
 from ccxt.base.types import Balances, Int, Order, OrderBook, Str, Ticker, Trade
 from ccxt.async_support.base.ws.client import Client
 from typing import List
-from ccxt.base.errors import ArgumentsRequired
 from ccxt.base.errors import AuthenticationError
+from ccxt.base.errors import ArgumentsRequired
 
 
 class okcoin(ccxt.async_support.okcoin):

ccxt/pro/okx.py

@@ -9,10 +9,10 @@ import hashlib
 from ccxt.base.types import Balances, Int, Num, Order, OrderBook, OrderSide, OrderType, Position, Str, Strings, Ticker, Tickers, Trade
 from ccxt.async_support.base.ws.client import Client
 from typing import List
+from ccxt.base.errors import AuthenticationError
 from ccxt.base.errors import ArgumentsRequired
 from ccxt.base.errors import BadRequest
 from ccxt.base.errors import InvalidNonce
-from ccxt.base.errors import AuthenticationError
 
 
 class okx(ccxt.async_support.okx):

ccxt/pro/poloniex.py

@@ -10,9 +10,9 @@ from ccxt.base.types import Balances, Int, Num, Order, OrderBook, OrderSide, Ord
 from ccxt.async_support.base.ws.client import Client
 from typing import List
 from ccxt.base.errors import ExchangeError
+from ccxt.base.errors import AuthenticationError
 from ccxt.base.errors import BadRequest
 from ccxt.base.errors import InvalidOrder
-from ccxt.base.errors import AuthenticationError
 from ccxt.base.precise import Precise
 
 

ccxt/pro/poloniexfutures.py

@@ -9,8 +9,8 @@ from ccxt.base.types import Balances, Int, Order, OrderBook, Str, Ticker, Trade
 from ccxt.async_support.base.ws.client import Client
 from typing import List
 from ccxt.base.errors import ExchangeError
-from ccxt.base.errors import BadRequest
 from ccxt.base.errors import AuthenticationError
+from ccxt.base.errors import BadRequest
 
 
 class poloniexfutures(ccxt.async_support.poloniexfutures):

ccxt/pro/whitebit.py

@@ -8,9 +8,9 @@ from ccxt.async_support.base.ws.cache import ArrayCache, ArrayCacheBySymbolById,
 from ccxt.base.types import Balances, Int, Order, OrderBook, Str, Ticker, Trade
 from ccxt.async_support.base.ws.client import Client
 from typing import List
+from ccxt.base.errors import AuthenticationError
 from ccxt.base.errors import ArgumentsRequired
 from ccxt.base.errors import BadRequest
-from ccxt.base.errors import AuthenticationError
 from ccxt.base.precise import Precise
 
 

ccxt/probit.py

@@ -9,6 +9,7 @@ import math
 from ccxt.base.types import Balances, Currencies, Currency, Int, Market, Num, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, Transaction
 from typing import List
 from ccxt.base.errors import ExchangeError
+from ccxt.base.errors import AuthenticationError
 from ccxt.base.errors import ArgumentsRequired
 from ccxt.base.errors import BadRequest
 from ccxt.base.errors import BadSymbol
@@ -19,7 +20,6 @@ from ccxt.base.errors import InvalidOrder
 from ccxt.base.errors import DDoSProtection
 from ccxt.base.errors import RateLimitExceeded
 from ccxt.base.errors import ExchangeNotAvailable
-from ccxt.base.errors import AuthenticationError
 from ccxt.base.decimal_to_precision import TRUNCATE
 from ccxt.base.decimal_to_precision import TICK_SIZE
 from ccxt.base.precise import Precise

ccxt/timex.py

@@ -8,6 +8,7 @@ from ccxt.abstract.timex import ImplicitAPI
 from ccxt.base.types import Balances, Currencies, Currency, Int, Market, Num, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, TradingFeeInterface, Transaction
 from typing import List
 from ccxt.base.errors import ExchangeError
+from ccxt.base.errors import AuthenticationError
 from ccxt.base.errors import PermissionDenied
 from ccxt.base.errors import ArgumentsRequired
 from ccxt.base.errors import BadRequest
@@ -17,7 +18,6 @@ from ccxt.base.errors import OrderNotFound
 from ccxt.base.errors import NotSupported
 from ccxt.base.errors import RateLimitExceeded
 from ccxt.base.errors import ExchangeNotAvailable
-from ccxt.base.errors import AuthenticationError
 from ccxt.base.decimal_to_precision import TICK_SIZE
 from ccxt.base.precise import Precise
 

ccxt/tokocrypto.py

@@ -10,6 +10,7 @@ import json
 from ccxt.base.types import Balances, Currency, Int, Market, Num, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, Transaction
 from typing import List
 from ccxt.base.errors import ExchangeError
+from ccxt.base.errors import AuthenticationError
 from ccxt.base.errors import PermissionDenied
 from ccxt.base.errors import AccountSuspended
 from ccxt.base.errors import ArgumentsRequired
@@ -29,7 +30,6 @@ from ccxt.base.errors import ExchangeNotAvailable
 from ccxt.base.errors import OnMaintenance
 from ccxt.base.errors import InvalidNonce
 from ccxt.base.errors import RequestTimeout
-from ccxt.base.errors import AuthenticationError
 from ccxt.base.decimal_to_precision import TRUNCATE
 from ccxt.base.decimal_to_precision import DECIMAL_PLACES
 from ccxt.base.precise import Precise

ccxt/tradeogre.py

@@ -8,9 +8,9 @@ from ccxt.abstract.tradeogre import ImplicitAPI
 from ccxt.base.types import IndexType, Int, Market, Num, Order, OrderSide, OrderType, Str, Ticker
 from typing import List
 from ccxt.base.errors import ExchangeError
+from ccxt.base.errors import AuthenticationError
 from ccxt.base.errors import BadRequest
 from ccxt.base.errors import InsufficientFunds
-from ccxt.base.errors import AuthenticationError
 from ccxt.base.decimal_to_precision import TICK_SIZE
 
 

ccxt/upbit.py

@@ -8,14 +8,14 @@ from ccxt.abstract.upbit import ImplicitAPI
 from ccxt.base.types import Balances, Currency, Int, Market, Num, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, TradingFeeInterface, Transaction
 from typing import List
 from ccxt.base.errors import ExchangeError
+from ccxt.base.errors import AuthenticationError
 from ccxt.base.errors import PermissionDenied
 from ccxt.base.errors import ArgumentsRequired
 from ccxt.base.errors import BadRequest
 from ccxt.base.errors import InsufficientFunds
+from ccxt.base.errors import AddressPending
 from ccxt.base.errors import InvalidOrder
 from ccxt.base.errors import OrderNotFound
-from ccxt.base.errors import AuthenticationError
-from ccxt.base.errors import AddressPending
 from ccxt.base.decimal_to_precision import TICK_SIZE
 from ccxt.base.precise import Precise
 

ccxt/wavesexchange.py

@@ -10,6 +10,7 @@ from ccxt.base.types import Balances, Currency, Int, Market, Num, Order, OrderBo
 from typing import List
 from typing import Any
 from ccxt.base.errors import ExchangeError
+from ccxt.base.errors import AuthenticationError
 from ccxt.base.errors import AccountSuspended
 from ccxt.base.errors import ArgumentsRequired
 from ccxt.base.errors import BadRequest
@@ -19,7 +20,6 @@ from ccxt.base.errors import InvalidOrder
 from ccxt.base.errors import OrderNotFound
 from ccxt.base.errors import DuplicateOrderId
 from ccxt.base.errors import ExchangeNotAvailable
-from ccxt.base.errors import AuthenticationError
 from ccxt.base.decimal_to_precision import DECIMAL_PLACES
 from ccxt.base.precise import Precise
 

ccxt/whitebit.py

@@ -9,6 +9,7 @@ import hashlib
 from ccxt.base.types import Balances, Bool, Currencies, Currency, Int, Market, MarketType, Num, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, TradingFees, Transaction, TransferEntry
 from typing import List
 from ccxt.base.errors import ExchangeError
+from ccxt.base.errors import AuthenticationError
 from ccxt.base.errors import PermissionDenied
 from ccxt.base.errors import ArgumentsRequired
 from ccxt.base.errors import BadRequest
@@ -19,7 +20,6 @@ from ccxt.base.errors import OrderNotFound
 from ccxt.base.errors import NotSupported
 from ccxt.base.errors import DDoSProtection
 from ccxt.base.errors import ExchangeNotAvailable
-from ccxt.base.errors import AuthenticationError
 from ccxt.base.decimal_to_precision import TICK_SIZE
 from ccxt.base.precise import Precise