ccxt 4.4.75__py2.py3-none-any.whl → 4.4.78__py2.py3-none-any.whl

ccxt/pro/coinbase.py

@@ -641,10 +641,12 @@ class coinbase(ccxt.async_support.coinbase):
             event = events[i]
             updates = self.safe_value(event, 'updates', [])
             marketId = self.safe_string(event, 'product_id')
-            messageHash = 'level2::' + marketId
+            # sometimes we subscribe to BTC/USDC and coinbase returns BTC/USD, are aliases
+            market = self.safe_market(marketId)
+            messageHash = 'level2::' + market['id']
+            symbol = market['symbol']
             subscription = self.safe_value(client.subscriptions, messageHash, {})
             limit = self.safe_integer(subscription, 'limit')
-            symbol = self.safe_symbol(marketId)
             type = self.safe_string(event, 'type')
             if type == 'snapshot':
                 self.orderbooks[symbol] = self.order_book({}, limit)
@@ -654,8 +656,6 @@ class coinbase(ccxt.async_support.coinbase):
                 orderbook['datetime'] = datetime
                 orderbook['symbol'] = symbol
                 client.resolve(orderbook, messageHash)
-                if messageHash.endswith('USD'):
-                    client.resolve(orderbook, messageHash + 'C')  # sometimes we subscribe to BTC/USDC and coinbase returns BTC/USD
             elif type == 'update':
                 orderbook = self.orderbooks[symbol]
                 self.handle_order_book_helper(orderbook, updates)
@@ -663,8 +663,6 @@ class coinbase(ccxt.async_support.coinbase):
                 orderbook['timestamp'] = self.parse8601(datetime)
                 orderbook['symbol'] = symbol
                 client.resolve(orderbook, messageHash)
-                if messageHash.endswith('USD'):
-                    client.resolve(orderbook, messageHash + 'C')  # sometimes we subscribe to BTC/USDC and coinbase returns BTC/USD
 
     def handle_subscription_status(self, client, message):
         #

ccxt/pro/gate.py

@@ -1175,8 +1175,28 @@ class gate(ccxt.async_support.gate):
         for i in range(0, len(data)):
             rawPosition = data[i]
             position = self.parse_position(rawPosition)
-            newPositions.append(position)
-            cache.append(position)
+            symbol = self.safe_string(position, 'symbol')
+            side = self.safe_string(position, 'side')
+            # Control when position is closed no side is returned
+            if side is None:
+                prevLongPosition = self.safe_dict(cache, symbol + 'long')
+                if prevLongPosition is not None:
+                    position['side'] = prevLongPosition['side']
+                    newPositions.append(position)
+                    cache.append(position)
+                prevShortPosition = self.safe_dict(cache, symbol + 'short')
+                if prevShortPosition is not None:
+                    position['side'] = prevShortPosition['side']
+                    newPositions.append(position)
+                    cache.append(position)
+                # if no prev position is found, default to long
+                if prevLongPosition is None and prevShortPosition is None:
+                    position['side'] = 'long'
+                    newPositions.append(position)
+                    cache.append(position)
+            else:
+                newPositions.append(position)
+                cache.append(position)
         messageHashes = self.find_message_hashes(client, type + ':positions::')
         for i in range(0, len(messageHashes)):
             messageHash = messageHashes[i]

ccxt/pro/hollaex.py

@@ -572,8 +572,8 @@ class hollaex(ccxt.async_support.hollaex):
 
     def on_error(self, client: Client, error):
         self.options['ws-expires'] = None
-        self.on_error(client, error)
+        super(hollaex, self).on_error(client, error)
 
     def on_close(self, client: Client, error):
         self.options['ws-expires'] = None
-        self.on_close(client, error)
+        super(hollaex, self).on_close(client, error)

ccxt/pro/hyperliquid.py

@@ -614,7 +614,7 @@ class hyperliquid(ccxt.async_support.hyperliquid):
             'datetime': self.iso8601(timestamp),
             'symbol': symbol,
             'id': id,
-            'order': None,
+            'order': self.safe_string(trade, 'oid'),
             'type': None,
             'side': side,
             'takerOrMaker': None,

ccxt/pro/p2b.py

@@ -478,8 +478,8 @@ class p2b(ccxt.async_support.p2b):
 
     def on_error(self, client: Client, error):
         self.options['tickerSubs'] = self.create_safe_dictionary()
-        self.on_error(client, error)
+        super(p2b, self).on_error(client, error)
 
     def on_close(self, client: Client, error):
         self.options['tickerSubs'] = self.create_safe_dictionary()
-        self.on_close(client, error)
+        super(p2b, self).on_close(client, error)

ccxt/pro/tradeogre.py

@@ -0,0 +1,272 @@
+# -*- 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
+from ccxt.base.types import Any, Int, OrderBook, Trade
+from ccxt.async_support.base.ws.client import Client
+from typing import List
+
+
+class tradeogre(ccxt.async_support.tradeogre):
+
+    def describe(self) -> Any:
+        return self.deep_extend(super(tradeogre, self).describe(), {
+            'has': {
+                'ws': True,
+                'watchTrades': True,
+                'watchTradesForSymbols': True,
+                'watchOrderBook': True,
+                'watchOrderBookForSymbols': False,
+                'watchOHLCV': False,
+                'watchOHLCVForSymbols': False,
+                'watchOrders': False,
+                'watchMyTrades': False,
+                'watchTicker': False,
+                'watchTickers': False,
+                'watchBidsAsks': False,
+                'watchBalance': False,
+                'createOrderWs': False,
+                'editOrderWs': False,
+                'cancelOrderWs': False,
+                'cancelOrdersWs': False,
+            },
+            'urls': {
+                'api': {
+                    'ws': 'wss://tradeogre.com:8443',
+                },
+            },
+            'options': {
+            },
+            'streaming': {
+            },
+        })
+
+    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
+
+        https://tradeogre.com/help/api
+
+        :param str symbol: unified symbol of the market to fetch the order book for
+        :param int [limit]: the maximum amount of order book entries to return(not used by the exchange)
+        :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
+        """
+        await self.load_markets()
+        market = self.market(symbol)
+        url = self.urls['api']['ws']
+        messageHash = 'orderbook' + ':' + market['symbol']
+        request: dict = {
+            'a': 'subscribe',
+            'e': 'book',
+            't': market['id'],
+        }
+        orderbook = await self.watch(url, messageHash, self.extend(request, params), messageHash)
+        return orderbook.limit()
+
+    def handle_order_book(self, client: Client, message):
+        #
+        # initial snapshot is fetched with ccxt's fetchOrderBook
+        # the feed does not include a snapshot, just the deltas
+        #
+        #     {
+        #         "e": "book",
+        #         "t": "ETH-USDT",
+        #         "s": "10752324",
+        #         "d": {
+        #             "bids": {"1787.02497915": "0"},
+        #             "asks": {}
+        #         }
+        #     }
+        #
+        marketId = self.safe_string(message, 't')
+        symbol = self.safe_symbol(marketId)
+        if not (symbol in self.orderbooks):
+            self.orderbooks[symbol] = self.order_book({})
+        storedOrderBook = self.orderbooks[symbol]
+        nonce = self.safe_integer(storedOrderBook, 'nonce')
+        deltaNonce = self.safe_integer(message, 's')
+        messageHash = 'orderbook:' + symbol
+        if nonce is None:
+            cacheLength = len(storedOrderBook.cache)
+            snapshotDelay = self.handle_option('watchOrderBook', 'snapshotDelay', 6)
+            if cacheLength == snapshotDelay:
+                self.spawn(self.load_order_book, client, messageHash, symbol, None, {})
+            storedOrderBook.cache.append(message)
+            return
+        elif nonce >= deltaNonce:
+            return
+        self.handle_delta(storedOrderBook, message)
+        client.resolve(storedOrderBook, messageHash)
+
+    def handle_delta(self, orderbook, delta):
+        # timestamp = self.milliseconds()  # todo check if self is correct
+        # orderbook['timestamp'] = timestamp
+        # orderbook['datetime'] = self.iso8601(timestamp)
+        orderbook['nonce'] = self.safe_integer(delta, 's')
+        data = self.safe_dict(delta, 'd', {})
+        bids = self.safe_dict(data, 'bids', {})
+        asks = self.safe_dict(data, 'asks', {})
+        storedBids = orderbook['bids']
+        storedAsks = orderbook['asks']
+        self.handle_bid_asks(storedBids, bids)
+        self.handle_bid_asks(storedAsks, asks)
+
+    def handle_bid_asks(self, bookSide, bidAsks):
+        keys = list(bidAsks.keys())
+        for i in range(0, len(keys)):
+            price = self.safe_string(keys, i)
+            amount = self.safe_number(bidAsks, price)
+            bidAsk = [self.parse_number(price), amount]
+            bookSide.storeArray(bidAsk)
+        # for i in range(0, len(bidAsks)):
+        #     bidAsk = self.parse_bid_ask(bidAsks[i])
+        #     bookSide.storeArray(bidAsk)
+        # }
+
+    def get_cache_index(self, orderbook, deltas):
+        firstElement = deltas[0]
+        firstElementNonce = self.safe_integer(firstElement, 's')
+        nonce = self.safe_integer(orderbook, 'nonce')
+        if nonce < firstElementNonce:
+            return -1
+        for i in range(0, len(deltas)):
+            delta = deltas[i]
+            deltaNonce = self.safe_integer(delta, 's')
+            if deltaNonce == nonce:
+                return i + 1
+        return len(deltas)
+
+    async def watch_trades(self, symbol: str, since: Int = None, limit: Int = None, params={}) -> List[Trade]:
+        """
+        watches information on multiple trades made in a market
+
+        https://tradeogre.com/help/api
+
+        :param str symbol: unified market symbol of the market trades were made in
+        :param int [since]: the earliest time in ms to fetch trades for
+        :param int [limit]: the maximum number of trade structures to retrieve
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict[]: a list of `trade structures <https://docs.ccxt.com/#/?id=trade-structure>`
+        """
+        await self.load_markets()
+        market = self.market(symbol)
+        symbol = market['symbol']
+        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]:
+        """
+
+        https://tradeogre.com/help/api
+
+        get the list of most recent trades for a list of symbols
+        :param str[] symbols: unified symbol of the market to fetch trades for(empty array means all markets)
+        :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()
+        symbols = self.market_symbols(symbols, None, True)
+        messageHashes = []
+        symbolsLength = 0
+        if symbols is not None:
+            symbolsLength = len(symbols)
+        if symbolsLength > 0:
+            for i in range(0, len(symbols)):
+                symbol = symbols[i]
+                messageHash = 'trades:' + symbol
+                messageHashes.append(messageHash)
+        else:
+            messageHash = 'trades'
+            messageHashes.append(messageHash)
+        request: dict = {
+            'a': 'subscribe',
+            'e': 'trade',
+            't': '*',
+        }
+        url = self.urls['api']['ws']
+        trades = await self.watch_multiple(url, messageHashes, self.extend(request, params), ['trades'])
+        if self.newUpdates:
+            first = self.safe_dict(trades, 0)
+            tradeSymbol = self.safe_string(first, 'symbol')
+            limit = trades.getLimit(tradeSymbol, limit)
+        return self.filter_by_since_limit(trades, since, limit, 'timestamp', True)
+
+    def handle_trade(self, client: Client, message):
+        #
+        #     {
+        #         "e": "trade",
+        #         "t": "LTC-USDT",
+        #         "d": {
+        #             "t": 0,
+        #             "p": "84.50000000",
+        #             "q": "1.28471270",
+        #             "d": "1745392002"
+        #         }
+        #     }
+        #
+        marketId = self.safe_string(message, 't')
+        market = self.safe_market(marketId)
+        data = self.safe_dict(message, 'd', {})
+        symbol = market['symbol']
+        if not (symbol in self.trades):
+            limit = self.safe_integer(self.options, 'tradesLimit', 1000)
+            stored = ArrayCache(limit)
+            self.trades[symbol] = stored
+        cache = self.trades[symbol]
+        trade = self.parse_ws_trade(data, market)
+        cache.append(trade)
+        messageHash = 'trades:' + symbol
+        client.resolve(cache, messageHash)
+        client.resolve(cache, 'trades')
+
+    def parse_ws_trade(self, trade, market=None):
+        #
+        #     {
+        #         "t": 0,
+        #         "p": "84.50000000",
+        #         "q": "1.28471270",
+        #         "d": "1745392002"
+        #     }
+        #
+        timestamp = self.safe_integer_product(trade, 'd', 1000)
+        sideEnum = self.safe_string(trade, 't')
+        return self.safe_trade({
+            'info': trade,
+            'id': None,
+            'timestamp': timestamp,
+            'datetime': self.iso8601(timestamp),
+            'symbol': self.safe_string(market, 'symbol'),
+            'order': None,
+            'type': None,
+            'side': self.parse_ws_trade_side(sideEnum),
+            'takerOrMaker': None,
+            'price': self.safe_string(trade, 'p'),
+            'amount': self.safe_string(trade, 'q'),
+            'cost': None,
+            'fee': {
+                'currency': None,
+                'cost': None,
+            },
+        }, market)
+
+    def parse_ws_trade_side(self, side):
+        sides = {
+            '0': 'buy',
+            '1': 'sell',
+        }
+        return self.safe_string(sides, side, side)
+
+    def handle_message(self, client: Client, message):
+        methods: dict = {
+            'book': self.handle_order_book,
+            'trade': self.handle_trade,
+        }
+        event = self.safe_string(message, 'e')
+        method = self.safe_value(methods, event)
+        if method is not None:
+            method(client, message)

ccxt/probit.py

@@ -563,6 +563,7 @@ class probit(Exchange, ImplicitAPI):
                 'active': active,
                 'deposit': deposit,
                 'withdraw': withdraw,
+                'type': 'crypto',
                 'fee': fee,
                 'precision': self.parse_number(self.parse_precision(self.safe_string(platform, 'precision'))),
                 'limits': {

ccxt/test/tests_async.py

@@ -896,6 +896,8 @@ class testMainClass:
     async def test_request_statically(self, exchange, method, data, type, skip_keys):
         output = None
         request_url = None
+        if self.info:
+            dump('[INFO] STATIC REQUEST TEST:', method, ':', data['description'])
         try:
             if not is_sync():
                 await call_exchange_method_dynamically(exchange, method, self.sanitize_data_input(data['input']))
@@ -918,6 +920,8 @@ class testMainClass:
     async def test_response_statically(self, exchange, method, skip_keys, data):
         expected_result = exchange.safe_value(data, 'parsedResponse')
         mocked_exchange = set_fetch_response(exchange, data['httpResponse'])
+        if self.info:
+            dump('[INFO] STATIC RESPONSE TEST:', method, ':', data['description'])
         try:
             if not is_sync():
                 unified_result = await call_exchange_method_dynamically(exchange, method, self.sanitize_data_input(data['input']))
@@ -1094,6 +1098,26 @@ class testMainClass:
             sum = exchange.sum(sum, results_length)
         return sum
 
+    def check_if_exchange_is_disabled(self, exchange_name, exchange_data):
+        exchange = init_exchange('Exchange', {})
+        is_disabled_py = exchange.safe_bool(exchange_data, 'disabledPy', False)
+        if is_disabled_py and (self.lang == 'PY'):
+            dump('[TEST_WARNING] Exchange ' + exchange_name + ' is disabled in python')
+            return True
+        is_disabled_php = exchange.safe_bool(exchange_data, 'disabledPHP', False)
+        if is_disabled_php and (self.lang == 'PHP'):
+            dump('[TEST_WARNING] Exchange ' + exchange_name + ' is disabled in php')
+            return True
+        is_disabled_c_sharp = exchange.safe_bool(exchange_data, 'disabledCS', False)
+        if is_disabled_c_sharp and (self.lang == 'C#'):
+            dump('[TEST_WARNING] Exchange ' + exchange_name + ' is disabled in c#')
+            return True
+        is_disabled_go = exchange.safe_bool(exchange_data, 'disabledGO', False)
+        if is_disabled_go and (self.lang == 'GO'):
+            dump('[TEST_WARNING] Exchange ' + exchange_name + ' is disabled in go')
+            return True
+        return False
+
     async def run_static_request_tests(self, target_exchange=None, test_name=None):
         await self.run_static_tests('request', target_exchange, test_name)
         return True
@@ -1114,6 +1138,9 @@ class testMainClass:
         for i in range(0, len(exchanges)):
             exchange_name = exchanges[i]
             exchange_data = static_data[exchange_name]
+            disabled = self.check_if_exchange_is_disabled(exchange_name, exchange_data)
+            if disabled:
+                continue
             number_of_tests = self.get_number_of_tests_from_exchange(exchange, exchange_data, test_name)
             sum = exchange.sum(sum, number_of_tests)
             if type == 'request':

ccxt/test/tests_sync.py

@@ -893,6 +893,8 @@ class testMainClass:
     def test_request_statically(self, exchange, method, data, type, skip_keys):
         output = None
         request_url = None
+        if self.info:
+            dump('[INFO] STATIC REQUEST TEST:', method, ':', data['description'])
         try:
             if not is_sync():
                 call_exchange_method_dynamically(exchange, method, self.sanitize_data_input(data['input']))
@@ -915,6 +917,8 @@ class testMainClass:
     def test_response_statically(self, exchange, method, skip_keys, data):
         expected_result = exchange.safe_value(data, 'parsedResponse')
         mocked_exchange = set_fetch_response(exchange, data['httpResponse'])
+        if self.info:
+            dump('[INFO] STATIC RESPONSE TEST:', method, ':', data['description'])
         try:
             if not is_sync():
                 unified_result = call_exchange_method_dynamically(exchange, method, self.sanitize_data_input(data['input']))
@@ -1091,6 +1095,26 @@ class testMainClass:
             sum = exchange.sum(sum, results_length)
         return sum
 
+    def check_if_exchange_is_disabled(self, exchange_name, exchange_data):
+        exchange = init_exchange('Exchange', {})
+        is_disabled_py = exchange.safe_bool(exchange_data, 'disabledPy', False)
+        if is_disabled_py and (self.lang == 'PY'):
+            dump('[TEST_WARNING] Exchange ' + exchange_name + ' is disabled in python')
+            return True
+        is_disabled_php = exchange.safe_bool(exchange_data, 'disabledPHP', False)
+        if is_disabled_php and (self.lang == 'PHP'):
+            dump('[TEST_WARNING] Exchange ' + exchange_name + ' is disabled in php')
+            return True
+        is_disabled_c_sharp = exchange.safe_bool(exchange_data, 'disabledCS', False)
+        if is_disabled_c_sharp and (self.lang == 'C#'):
+            dump('[TEST_WARNING] Exchange ' + exchange_name + ' is disabled in c#')
+            return True
+        is_disabled_go = exchange.safe_bool(exchange_data, 'disabledGO', False)
+        if is_disabled_go and (self.lang == 'GO'):
+            dump('[TEST_WARNING] Exchange ' + exchange_name + ' is disabled in go')
+            return True
+        return False
+
     def run_static_request_tests(self, target_exchange=None, test_name=None):
         self.run_static_tests('request', target_exchange, test_name)
         return True
@@ -1111,6 +1135,9 @@ class testMainClass:
         for i in range(0, len(exchanges)):
             exchange_name = exchanges[i]
             exchange_data = static_data[exchange_name]
+            disabled = self.check_if_exchange_is_disabled(exchange_name, exchange_data)
+            if disabled:
+                continue
             number_of_tests = self.get_number_of_tests_from_exchange(exchange, exchange_data, test_name)
             sum = exchange.sum(sum, number_of_tests)
             if type == 'request':

ccxt/tradeogre.py

@@ -24,7 +24,7 @@ class tradeogre(Exchange, ImplicitAPI):
             'countries': [],
             'rateLimit': 100,
             'version': 'v2',
-            'pro': False,
+            'pro': True,
             'has': {
                 'CORS': None,
                 'spot': True,
@@ -525,6 +525,7 @@ class tradeogre(Exchange, ImplicitAPI):
             'asks': rawAsks,
         }
         orderbook = self.parse_order_book(rawOrderbook, symbol)
+        orderbook['nonce'] = self.safe_integer(response, 's')
         return orderbook
 
     def parse_bids_asks(self, bidasks, priceKey: IndexType = 0, amountKey: IndexType = 1, countOrIdKey: IndexType = 2):