ccxt 4.2.29__py2.py3-none-any.whl → 4.2.31__py2.py3-none-any.whl

ccxt/pro/bitmex.py

@@ -6,7 +6,7 @@
 import ccxt.async_support
 from ccxt.async_support.base.ws.cache import ArrayCache, ArrayCacheBySymbolById, ArrayCacheBySymbolBySide, ArrayCacheByTimestamp
 import hashlib
-from ccxt.base.types import Balances, Int, Order, OrderBook, Position, Str, Strings, Ticker, Trade
+from ccxt.base.types import Balances, Int, Order, OrderBook, Position, Str, Strings, Ticker, Tickers, Trade
 from ccxt.async_support.base.ws.client import Client
 from typing import List
 from ccxt.base.errors import ExchangeError
@@ -28,7 +28,7 @@ class bitmex(ccxt.async_support.bitmex):
                 'watchOrders': True,
                 'watchPostions': True,
                 'watchTicker': True,
-                'watchTickers': False,
+                'watchTickers': True,
                 'watchTrades': True,
                 'watchTradesForSymbols': True,
             },
@@ -79,6 +79,39 @@ class bitmex(ccxt.async_support.bitmex):
         }
         return await self.watch(url, messageHash, self.extend(request, params), messageHash)
 
+    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 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
+        :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
+        """
+        await self.load_markets()
+        symbols = self.market_symbols(symbols, None, True)
+        name = 'instrument'
+        url = self.urls['api']['ws']
+        messageHashes = []
+        if symbols is not None:
+            for i in range(0, len(symbols)):
+                symbol = symbols[i]
+                market = self.market(symbol)
+                hash = name + ':' + market['id']
+                messageHashes.append(hash)
+        else:
+            messageHashes.append(name)
+        request = {
+            'op': 'subscribe',
+            'args': messageHashes,
+        }
+        ticker = await self.watch_multiple(url, messageHashes, self.extend(request, params), messageHashes)
+        if self.newUpdates:
+            if symbols is None:
+                return ticker
+            result = {}
+            result[ticker['symbol']] = ticker
+            return result
+        return self.filter_by_array(self.tickers, 'symbol', symbols)
+
     def handle_ticker(self, client: Client, message):
         #
         #     {
@@ -307,18 +340,21 @@ class bitmex(ccxt.async_support.bitmex):
         #     }
         #
         table = self.safe_string(message, 'table')
-        data = self.safe_value(message, 'data', [])
+        data = self.safe_list(message, 'data', [])
+        tickers = {}
         for i in range(0, len(data)):
             update = data[i]
-            marketId = self.safe_value(update, 'symbol')
+            marketId = self.safe_string(update, 'symbol')
             market = self.safe_market(marketId)
             symbol = market['symbol']
             messageHash = table + ':' + marketId
-            ticker = self.safe_value(self.tickers, symbol, {})
-            info = self.safe_value(ticker, 'info', {})
+            ticker = self.safe_dict(self.tickers, symbol, {})
+            info = self.safe_dict(ticker, 'info', {})
             ticker = self.parse_ticker(self.extend(info, update), market)
+            tickers[symbol] = ticker
             self.tickers[symbol] = ticker
             client.resolve(ticker, messageHash)
+        client.resolve(tickers, 'instrument')
         return message
 
     async def watch_balance(self, params={}) -> Balances:
@@ -573,7 +609,7 @@ class bitmex(ccxt.async_support.bitmex):
         return future
 
     def handle_authentication_message(self, client: Client, message):
-        authenticated = self.safe_value(message, 'success', False)
+        authenticated = self.safe_bool(message, 'success', False)
         messageHash = 'authenticated'
         if authenticated:
             # we resolve the future here permanently so authentication only happens once

ccxt/pro/bitvavo.py

@@ -1152,7 +1152,7 @@ class bitvavo(ccxt.async_support.bitvavo):
         #     }
         #
         messageHash = 'authenticated'
-        authenticated = self.safe_value(message, 'authenticated', False)
+        authenticated = self.safe_bool(message, 'authenticated', False)
         if authenticated:
             # we resolve the future here permanently so authentication only happens once
             client.resolve(message, messageHash)

ccxt/pro/bybit.py

@@ -1259,8 +1259,8 @@ class bybit(ccxt.async_support.bybit):
         subType = None
         subType, params = self.handle_sub_type_and_params('watchBalance', None, params)
         unified = await self.isUnifiedEnabled()
-        isUnifiedMargin = self.safe_value(unified, 0, False)
-        isUnifiedAccount = self.safe_value(unified, 1, False)
+        isUnifiedMargin = self.safe_bool(unified, 0, False)
+        isUnifiedAccount = self.safe_bool(unified, 1, False)
         url = self.get_url_by_market_type(None, True, method, params)
         await self.authenticate(url)
         topicByMarket = {

ccxt/pro/cex.py

@@ -686,7 +686,7 @@ class cex(ccxt.async_support.cex):
         if order is None:
             order = self.parse_ws_order_update(data, market)
         order['remaining'] = remains
-        canceled = self.safe_value(data, 'cancel', False)
+        canceled = self.safe_bool(data, 'cancel', False)
         if canceled:
             order['status'] = 'canceled'
         if isTransaction:
@@ -767,7 +767,7 @@ class cex(ccxt.async_support.cex):
         timestamp = time
         if isTransaction:
             timestamp = self.parse8601(time)
-        canceled = self.safe_value(order, 'cancel', False)
+        canceled = self.safe_bool(order, 'cancel', False)
         status = 'open'
         if canceled:
             status = 'canceled'

ccxt/pro/independentreserve.py

@@ -179,7 +179,7 @@ class independentreserve(ccxt.async_support.independentreserve):
         orderBook = self.safe_value(message, 'Data', {})
         messageHash = 'orderbook:' + symbol + ':' + depth
         subscription = self.safe_value(client.subscriptions, messageHash, {})
-        receivedSnapshot = self.safe_value(subscription, 'receivedSnapshot', False)
+        receivedSnapshot = self.safe_bool(subscription, 'receivedSnapshot', False)
         timestamp = self.safe_integer(message, 'Time')
         storedOrderBook = self.safe_value(self.orderbooks, symbol)
         if storedOrderBook is None:

ccxt/pro/okx.py

@@ -815,7 +815,7 @@ class okx(ccxt.async_support.okx):
         # By default, receive order updates from any instrument type
         type = None
         type, params = self.handle_option_and_params(params, 'watchMyTrades', 'type', 'ANY')
-        isStop = self.safe_value(params, 'stop', False)
+        isStop = self.safe_bool(params, 'stop', False)
         params = self.omit(params, ['stop'])
         await self.load_markets()
         await self.authenticate({'access': 'business' if isStop else 'private'})

ccxt/pro/onetrading.py

@@ -1020,7 +1020,7 @@ class onetrading(ccxt.async_support.onetrading):
             subscription = self.safe_value(client.subscriptions, subscriptionHash)
             if subscription is not None:
                 ohlcvMarket = self.safe_value(subscription, marketId, {})
-                marketSubscribed = self.safe_value(ohlcvMarket, timeframe, False)
+                marketSubscribed = self.safe_bool(ohlcvMarket, timeframe, False)
                 if not marketSubscribed:
                     type = 'UPDATE_SUBSCRIPTION'
                     client.subscriptions[subscriptionHash] = None
@@ -1245,7 +1245,7 @@ class onetrading(ccxt.async_support.onetrading):
             if subscription is not None:
                 for i in range(0, len(marketIds)):
                     marketId = marketIds[i]
-                    marketSubscribed = self.safe_value(subscription, marketId, False)
+                    marketSubscribed = self.safe_bool(subscription, marketId, False)
                     if not marketSubscribed:
                         type = 'UPDATE_SUBSCRIPTION'
                         client.subscriptions[subscriptionHash] = None

ccxt/pro/p2b.py

@@ -0,0 +1,407 @@
+# -*- coding: utf-8 -*-
+
+# PLEASE DO NOT EDIT THIS FILE, IT IS GENERATED AND WILL BE OVERWRITTEN:
+# https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code
+
+import ccxt.async_support
+from ccxt.async_support.base.ws.cache import ArrayCache, ArrayCacheByTimestamp
+from ccxt.base.types import Int, OrderBook, 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
+
+
+class p2b(ccxt.async_support.p2b):
+
+    def describe(self):
+        return self.deep_extend(super(p2b, self).describe(), {
+            'has': {
+                'ws': True,
+                'cancelAllOrdersWs': False,
+                'cancelOrdersWs': False,
+                'cancelOrderWs': False,
+                'createOrderWs': False,
+                'editOrderWs': False,
+                'fetchBalanceWs': False,
+                'fetchOpenOrdersWs': False,
+                'fetchOrderWs': False,
+                'fetchTradesWs': False,
+                'watchBalance': False,
+                'watchMyTrades': False,
+                'watchOHLCV': True,
+                'watchOrderBook': True,
+                'watchOrders': False,
+                # 'watchStatus': True,
+                'watchTicker': True,
+                'watchTickers': False,  # in the docs but does not return anything when subscribed to
+                'watchTrades': True,
+            },
+            'urls': {
+                'api': {
+                    'ws': 'wss://apiws.p2pb2b.com/',
+                },
+            },
+            'options': {
+                'OHLCVLimit': 1000,
+                'tradesLimit': 1000,
+                'timeframes': {
+                    '15m': 900,
+                    '30m': 1800,
+                    '1h': 3600,
+                    '1d': 86400,
+                },
+                'watchTicker': {
+                    'name': 'state',  # or 'price'
+                },
+                'watchTickers': {
+                    'name': 'state',  # or 'price'
+                },
+            },
+            'streaming': {
+                'ping': self.ping,
+            },
+        })
+
+    async def subscribe(self, name: str, messageHash: str, request, params={}):
+        """
+         * @ignore
+        Connects to a websocket channel
+        :param str name: name of the channel
+        :param str messageHash: string to look up in handler
+        :param str[]|float[] request: endpoint parameters
+        :param dict [params]: extra parameters specific to the p2b api
+        :returns dict: data from the websocket stream
+        """
+        url = self.urls['api']['ws']
+        subscribe = {
+            'method': name,
+            'params': request,
+            'id': self.milliseconds(),
+        }
+        query = self.extend(subscribe, params)
+        return await self.watch(url, messageHash, query, messageHash)
+
+    async def watch_ohlcv(self, symbol: str, timeframe='15m', since: Int = None, limit: Int = None, params={}) -> List[list]:
+        """
+        watches historical candlestick data containing the open, high, low, and close price, and the volume of a market. Can only subscribe to one timeframe at a time for each symbol
+        :see: https://github.com/P2B-team/P2B-WSS-Public/blob/main/wss_documentation.md#kline-candlestick
+        :param str symbol: unified symbol of the market to fetch OHLCV data for
+        :param str timeframe: 15m, 30m, 1h or 1d
+        :param int [since]: timestamp in ms of the earliest candle to fetch
+        :param int [limit]: the maximum amount of candles to fetch
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns int[][]: A list of candles ordered, open, high, low, close, volume
+        """
+        await self.load_markets()
+        timeframes = self.safe_value(self.options, 'timeframes', {})
+        channel = self.safe_integer(timeframes, timeframe)
+        if channel is None:
+            raise BadRequest(self.id + ' watchOHLCV cannot take a timeframe of ' + timeframe)
+        market = self.market(symbol)
+        request = [
+            market['id'],
+            channel,
+        ]
+        messageHash = 'kline::' + market['symbol']
+        ohlcv = await self.subscribe('kline.subscribe', messageHash, request, params)
+        if self.newUpdates:
+            limit = ohlcv.getLimit(symbol, limit)
+        return self.filter_by_since_limit(ohlcv, since, limit, 0, True)
+
+    async def watch_ticker(self, symbol: str, params={}) -> Ticker:
+        """
+        watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
+        :see: https://github.com/P2B-team/P2B-WSS-Public/blob/main/wss_documentation.md#last-price
+        :see: https://github.com/P2B-team/P2B-WSS-Public/blob/main/wss_documentation.md#market-status
+        :param str symbol: unified symbol of the market to fetch the ticker for
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param dict [params.method]: 'state'(default) or 'price'
+        :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
+        """
+        await self.load_markets()
+        watchTickerOptions = self.safe_value(self.options, 'watchTicker')
+        name = self.safe_string(watchTickerOptions, 'name', 'state')  # or price
+        name, params = self.handle_option_and_params(params, 'method', 'name', name)
+        market = self.market(symbol)
+        request = [
+            market['id'],
+        ]
+        messageHash = name + '::' + market['symbol']
+        return await self.subscribe(name + '.subscribe', messageHash, request, params)
+
+    async def watch_trades(self, symbol: str, since: Int = None, limit: Int = None, params={}) -> List[Trade]:
+        """
+        get the list of most recent trades for a particular symbol
+        :see: https://github.com/P2B-team/P2B-WSS-Public/blob/main/wss_documentation.md#deals
+        :param str symbol: 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>`
+        """
+        await self.load_markets()
+        market = self.market(symbol)
+        request = [
+            market['id'],
+        ]
+        messageHash = 'deals::' + market['symbol']
+        trades = await self.subscribe('deals.subscribe', messageHash, request, params)
+        if self.newUpdates:
+            limit = trades.getLimit(symbol, 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:
+        """
+        watches information on open orders with bid(buy) and ask(sell) prices, volumes and other data
+        :see: https://github.com/P2B-team/P2B-WSS-Public/blob/main/wss_documentation.md#depth-of-market
+        :param str symbol: unified symbol of the market to fetch the order book for
+        :param int [limit]: 1-100, default=100
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param float [params.interval]: 0, 0.00000001, 0.0000001, 0.000001, 0.00001, 0.0001, 0.001, 0.01, 0.1, interval of precision for order, default=0.001
+        :returns dict: A dictionary of `order book structures <https://docs.ccxt.com/#/?id=order-book-structure>` indexed by market symbols
+        """
+        await self.load_markets()
+        market = self.market(symbol)
+        name = 'depth.subscribe'
+        messageHash = 'orderbook::' + market['symbol']
+        interval = self.safe_string(params, 'interval', '0.001')
+        if limit is None:
+            limit = 100
+        request = [
+            market['id'],
+            limit,
+            interval,
+        ]
+        orderbook = await self.subscribe(name, messageHash, request, params)
+        return orderbook.limit()
+
+    def handle_ohlcv(self, client: Client, message):
+        #
+        #    {
+        #        "method": "kline.update",
+        #        "params": [
+        #            [
+        #                1657648800,             # Kline start time
+        #                "0.054146",             # Kline open price
+        #                "0.053938",             # Kline close price(current price)
+        #                "0.054146",             # Kline high price
+        #                "0.053911",             # Kline low price
+        #                "596.4674",             # Volume for stock currency
+        #                "32.2298758767",        # Volume for money currency
+        #                "ETH_BTC"               # Market
+        #            ]
+        #        ],
+        #        "id": null
+        #    }
+        #
+        data = self.safe_list(message, 'params')
+        data = self.safe_list(data, 0)
+        method = self.safe_string(message, 'method')
+        splitMethod = method.split('.')
+        channel = self.safe_string(splitMethod, 0)
+        marketId = self.safe_string(data, 7)
+        market = self.safe_market(marketId)
+        timeframes = self.safe_dict(self.options, 'timeframes', {})
+        timeframe = self.find_timeframe(channel, timeframes)
+        symbol = self.safe_string(market, 'symbol')
+        messageHash = channel + '::' + symbol
+        parsed = self.parse_ohlcv(data, market)
+        self.ohlcvs[symbol] = self.safe_value(self.ohlcvs, symbol, {})
+        stored = self.safe_value(self.ohlcvs[symbol], timeframe)
+        if symbol is not None:
+            if stored is None:
+                limit = self.safe_integer(self.options, 'OHLCVLimit', 1000)
+                stored = ArrayCacheByTimestamp(limit)
+                self.ohlcvs[symbol][timeframe] = stored
+            stored.append(parsed)
+            client.resolve(stored, messageHash)
+        return message
+
+    def handle_trade(self, client: Client, message):
+        #
+        #    {
+        #        "method": "deals.update",
+        #        "params": [
+        #            "ETH_BTC",
+        #            [
+        #                {
+        #                    "id": 4503032979,               # Order_id
+        #                    "amount": "0.103",
+        #                    "type": "sell",                 # Side
+        #                    "time": 1657661950.8487639,     # Creation time
+        #                    "price": "0.05361"
+        #                },
+        #                ...
+        #            ]
+        #        ],
+        #        "id": null
+        #    }
+        #
+        data = self.safe_list(message, 'params', [])
+        trades = self.safe_list(data, 1)
+        marketId = self.safe_string(data, 0)
+        market = self.safe_market(marketId)
+        symbol = self.safe_string(market, 'symbol')
+        tradesArray = self.safe_value(self.trades, symbol)
+        if tradesArray is None:
+            tradesLimit = self.safe_integer(self.options, 'tradesLimit', 1000)
+            tradesArray = ArrayCache(tradesLimit)
+            self.trades[symbol] = tradesArray
+        for i in range(0, len(trades)):
+            item = trades[i]
+            trade = self.parse_trade(item, market)
+            tradesArray.append(trade)
+        messageHash = 'deals::' + symbol
+        client.resolve(tradesArray, messageHash)
+        return message
+
+    def handle_ticker(self, client: Client, message):
+        #
+        # state
+        #
+        #    {
+        #        "method": "state.update",
+        #        "params": [
+        #            "ETH_BTC",
+        #            {
+        #                "high": "0.055774",         # High price for the last 24h
+        #                "close": "0.053679",        # Close price for the last 24h
+        #                "low": "0.053462",          # Low price for the last 24h
+        #                "period": 86400,            # Period 24h
+        #                "last": "0.053679",         # Last price for the last 24h
+        #                "volume": "38463.6132",     # Stock volume for the last 24h
+        #                "open": "0.055682",         # Open price for the last 24h
+        #                "deal": "2091.0038055314"   # Money volume for the last 24h
+        #            }
+        #        ],
+        #        "id": null
+        #    }
+        #
+        # price
+        #
+        #    {
+        #        "method": "price.update",
+        #        "params": [
+        #            "ETH_BTC",      # market
+        #            "0.053836"      # last price
+        #        ],
+        #        "id": null
+        #    }
+        #
+        data = self.safe_list(message, 'params', [])
+        marketId = self.safe_string(data, 0)
+        market = self.safe_market(marketId)
+        method = self.safe_string(message, 'method')
+        splitMethod = method.split('.')
+        messageHashStart = self.safe_string(splitMethod, 0)
+        tickerData = self.safe_dict(data, 1)
+        ticker = None
+        if method == 'price.update':
+            lastPrice = self.safe_string(data, 1)
+            ticker = self.safe_ticker({
+                'last': lastPrice,
+                'close': lastPrice,
+                'symbol': market['symbol'],
+            })
+        else:
+            ticker = self.parse_ticker(tickerData, market)
+        symbol = ticker['symbol']
+        messageHash = messageHashStart + '::' + symbol
+        client.resolve(ticker, messageHash)
+        return message
+
+    def handle_order_book(self, client: Client, message):
+        #
+        #    {
+        #        "method": "depth.update",
+        #        "params": [
+        #            False,                          # True - all records, False - new records
+        #            {
+        #                "asks": [                  # side
+        #                    [
+        #                        "19509.81",         # price
+        #                        "0.277"             # amount
+        #                    ]
+        #                ]
+        #            },
+        #            "BTC_USDT"
+        #        ],
+        #        "id": null
+        #    }
+        #
+        params = self.safe_list(message, 'params', [])
+        data = self.safe_dict(params, 1)
+        asks = self.safe_list(data, 'asks')
+        bids = self.safe_list(data, 'bids')
+        marketId = self.safe_string(params, 2)
+        market = self.safe_market(marketId)
+        symbol = market['symbol']
+        messageHash = 'orderbook::' + market['symbol']
+        subscription = self.safe_value(client.subscriptions, messageHash, {})
+        limit = self.safe_integer(subscription, 'limit')
+        orderbook = self.safe_value(self.orderbooks, symbol)
+        if orderbook is None:
+            self.orderbooks[symbol] = self.order_book({}, limit)
+            orderbook = self.orderbooks[symbol]
+        if bids is not None:
+            for i in range(0, len(bids)):
+                bid = self.safe_value(bids, i)
+                price = self.safe_number(bid, 0)
+                amount = self.safe_number(bid, 1)
+                orderbook['bids'].store(price, amount)
+        if asks is not None:
+            for i in range(0, len(asks)):
+                ask = self.safe_value(asks, i)
+                price = self.safe_number(ask, 0)
+                amount = self.safe_number(ask, 1)
+                orderbook['asks'].store(price, amount)
+        orderbook['symbol'] = symbol
+        client.resolve(orderbook, messageHash)
+
+    def handle_message(self, client: Client, message):
+        if self.handle_error_message(client, message):
+            return
+        result = self.safe_string(message, 'result')
+        if result == 'pong':
+            self.handle_pong(client, message)
+            return
+        method = self.safe_string(message, 'method')
+        methods = {
+            'depth.update': self.handle_order_book,
+            'price.update': self.handle_ticker,
+            'kline.update': self.handle_ohlcv,
+            'state.update': self.handle_ticker,
+            'deals.update': self.handle_trade,
+        }
+        endpoint = self.safe_value(methods, method)
+        if endpoint is not None:
+            return endpoint(client, message)
+
+    def handle_error_message(self, client: Client, message):
+        error = self.safe_string(message, 'error')
+        if error is not None:
+            raise ExchangeError(self.id + ' error: ' + self.json(error))
+        return False
+
+    def ping(self, client):
+        """
+        :see: https://github.com/P2B-team/P2B-WSS-Public/blob/main/wss_documentation.md#ping
+         * @param client
+        """
+        return {
+            'method': 'server.ping',
+            'params': [],
+            'id': self.milliseconds(),
+        }
+
+    def handle_pong(self, client: Client, message):
+        #
+        #    {
+        #        error: null,
+        #        result: 'pong',
+        #        id: 1706539608030
+        #    }
+        #
+        client.lastPong = self.safe_integer(message, 'id')
+        return message

ccxt/pro/probit.py

@@ -103,7 +103,7 @@ class probit(ccxt.async_support.probit):
         #         }
         #     }
         #
-        reset = self.safe_value(message, 'reset', False)
+        reset = self.safe_bool(message, 'reset', False)
         data = self.safe_value(message, 'data', {})
         currencyIds = list(data.keys())
         if reset:
@@ -202,7 +202,7 @@ class probit(ccxt.async_support.probit):
         symbol = self.safe_symbol(marketId)
         market = self.safe_market(marketId)
         trades = self.safe_value(message, 'recent_trades', [])
-        reset = self.safe_value(message, 'reset', False)
+        reset = self.safe_bool(message, 'reset', False)
         messageHash = 'trades:' + symbol
         stored = self.safe_value(self.trades, symbol)
         if stored is None or reset:
@@ -268,7 +268,7 @@ class probit(ccxt.async_support.probit):
         length = len(rawTrades)
         if length == 0:
             return
-        reset = self.safe_value(message, 'reset', False)
+        reset = self.safe_bool(message, 'reset', False)
         messageHash = 'myTrades'
         stored = self.myTrades
         if (stored is None) or reset:
@@ -348,7 +348,7 @@ class probit(ccxt.async_support.probit):
         if length == 0:
             return
         messageHash = 'orders'
-        reset = self.safe_value(message, 'reset', False)
+        reset = self.safe_bool(message, 'reset', False)
         stored = self.orders
         if stored is None or reset:
             limit = self.safe_integer(self.options, 'ordersLimit', 1000)
@@ -432,7 +432,7 @@ class probit(ccxt.async_support.probit):
         if storedOrderBook is None:
             storedOrderBook = self.order_book({})
             self.orderbooks[symbol] = storedOrderBook
-        reset = self.safe_value(message, 'reset', False)
+        reset = self.safe_bool(message, 'reset', False)
         if reset:
             snapshot = self.parse_order_book(dataBySide, symbol, None, 'buy', 'sell', 'price', 'quantity')
             storedOrderBook.reset(snapshot)

ccxt/pro/whitebit.py

@@ -698,7 +698,7 @@ class whitebit(ccxt.async_support.whitebit):
             hasSymbolSubscription = True
             market = self.market(symbol)
             marketId = market['id']
-            isSubscribed = self.safe_value(subscription, marketId, False)
+            isSubscribed = self.safe_bool(subscription, marketId, False)
             if not isSubscribed:
                 subscription[marketId] = True
                 hasSymbolSubscription = False

ccxt/probit.py

@@ -297,7 +297,7 @@ class probit(Exchange, ImplicitAPI):
         quoteId = self.safe_string(market, 'quote_currency_id')
         base = self.safe_currency_code(baseId)
         quote = self.safe_currency_code(quoteId)
-        closed = self.safe_value(market, 'closed', False)
+        closed = self.safe_bool(market, 'closed', False)
         takerFeeRate = self.safe_string(market, 'taker_fee_rate')
         taker = Precise.string_div(takerFeeRate, '100')
         makerFeeRate = self.safe_string(market, 'maker_fee_rate')

ccxt/timex.py

@@ -109,7 +109,7 @@ class timex(Exchange, ImplicitAPI):
                     'rest': 'https://plasma-relay-backend.timex.io',
                 },
                 'www': 'https://timex.io',
-                'doc': 'https://docs.timex.io',
+                'doc': 'https://plasma-relay-backend.timex.io/swagger-ui/index.html',
                 'referral': 'https://timex.io/?refcode=1x27vNkTbP1uwkCck',
             },
             'api': {
@@ -701,7 +701,7 @@ class timex(Exchange, ImplicitAPI):
         market = self.market(symbol)
         uppercaseSide = side.upper()
         uppercaseType = type.upper()
-        postOnly = self.safe_value(params, 'postOnly', False)
+        postOnly = self.safe_bool(params, 'postOnly', False)
         if postOnly:
             uppercaseType = 'POST_ONLY'
             params = self.omit(params, ['postOnly'])