ccxt 4.1.85__py2.py3-none-any.whl → 4.1.86__py2.py3-none-any.whl

ccxt/pro/bitmex.py

@@ -4,9 +4,9 @@
 # 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, ArrayCacheBySymbolById, ArrayCacheByTimestamp
+from ccxt.async_support.base.ws.cache import ArrayCache, ArrayCacheBySymbolById, ArrayCacheBySymbolBySide, ArrayCacheByTimestamp
 import hashlib
-from ccxt.base.types import Int, Str
+from ccxt.base.types import Int, Str, Strings
 from ccxt.async_support.base.ws.client import Client
 from typing import List
 from ccxt.base.errors import ExchangeError
@@ -26,6 +26,7 @@ class bitmex(ccxt.async_support.bitmex):
                 'watchOrderBook': True,
                 'watchOrderBookForSymbols': True,
                 'watchOrders': True,
+                'watchPostions': True,
                 'watchTicker': True,
                 'watchTickers': False,
                 'watchTrades': True,
@@ -585,6 +586,202 @@ class bitmex(ccxt.async_support.bitmex):
             if messageHash in client.subscriptions:
                 del client.subscriptions[messageHash]
 
+    async def watch_positions(self, symbols: Strings = None, since: Int = None, limit: Int = None, params={}):
+        """
+        :see: https://www.bitmex.com/app/wsAPI
+        watch all open positions
+        :param str[]|None 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>`
+        """
+        await self.load_markets()
+        await self.authenticate()
+        subscriptionHash = 'position'
+        messageHash = 'positions'
+        if not self.is_empty(symbols):
+            messageHash = '::' + ','.join(symbols)
+        url = self.urls['api']['ws']
+        request = {
+            'op': 'subscribe',
+            'args': [
+                subscriptionHash,
+            ],
+        }
+        newPositions = await self.watch(url, messageHash, request, subscriptionHash)
+        if self.newUpdates:
+            return newPositions
+        return self.filter_by_symbols_since_limit(self.positions, symbols, since, limit, True)
+
+    def handle_positions(self, client, message):
+        #
+        # partial
+        #    {
+        #        table: 'position',
+        #        action: 'partial',
+        #        keys: ['account', 'symbol'],
+        #        types: {
+        #            account: 'long',
+        #            symbol: 'symbol',
+        #            currency: 'symbol',
+        #            underlying: 'symbol',
+        #            quoteCurrency: 'symbol',
+        #            commission: 'float',
+        #            initMarginReq: 'float',
+        #            maintMarginReq: 'float',
+        #            riskLimit: 'long',
+        #            leverage: 'float',
+        #            crossMargin: 'boolean',
+        #            deleveragePercentile: 'float',
+        #            rebalancedPnl: 'long',
+        #            prevRealisedPnl: 'long',
+        #            prevUnrealisedPnl: 'long',
+        #            openingQty: 'long',
+        #            openOrderBuyQty: 'long',
+        #            openOrderBuyCost: 'long',
+        #            openOrderBuyPremium: 'long',
+        #            openOrderSellQty: 'long',
+        #            openOrderSellCost: 'long',
+        #            openOrderSellPremium: 'long',
+        #            currentQty: 'long',
+        #            currentCost: 'long',
+        #            currentComm: 'long',
+        #            realisedCost: 'long',
+        #            unrealisedCost: 'long',
+        #            grossOpenPremium: 'long',
+        #            isOpen: 'boolean',
+        #            markPrice: 'float',
+        #            markValue: 'long',
+        #            riskValue: 'long',
+        #            homeNotional: 'float',
+        #            foreignNotional: 'float',
+        #            posState: 'symbol',
+        #            posCost: 'long',
+        #            posCross: 'long',
+        #            posComm: 'long',
+        #            posLoss: 'long',
+        #            posMargin: 'long',
+        #            posMaint: 'long',
+        #            initMargin: 'long',
+        #            maintMargin: 'long',
+        #            realisedPnl: 'long',
+        #            unrealisedPnl: 'long',
+        #            unrealisedPnlPcnt: 'float',
+        #            unrealisedRoePcnt: 'float',
+        #            avgCostPrice: 'float',
+        #            avgEntryPrice: 'float',
+        #            breakEvenPrice: 'float',
+        #            marginCallPrice: 'float',
+        #            liquidationPrice: 'float',
+        #            bankruptPrice: 'float',
+        #            timestamp: 'timestamp'
+        #        },
+        #        filter: {account: 412475},
+        #        data: [
+        #            {
+        #                account: 412475,
+        #                symbol: 'XBTUSD',
+        #                currency: 'XBt',
+        #                underlying: 'XBT',
+        #                quoteCurrency: 'USD',
+        #                commission: 0.00075,
+        #                initMarginReq: 0.01,
+        #                maintMarginReq: 0.0035,
+        #                riskLimit: 20000000000,
+        #                leverage: 100,
+        #                crossMargin: True,
+        #                deleveragePercentile: 1,
+        #                rebalancedPnl: 0,
+        #                prevRealisedPnl: 0,
+        #                prevUnrealisedPnl: 0,
+        #                openingQty: 400,
+        #                openOrderBuyQty: 0,
+        #                openOrderBuyCost: 0,
+        #                openOrderBuyPremium: 0,
+        #                openOrderSellQty: 0,
+        #                openOrderSellCost: 0,
+        #                openOrderSellPremium: 0,
+        #                currentQty: 400,
+        #                currentCost: -912269,
+        #                currentComm: 684,
+        #                realisedCost: 0,
+        #                unrealisedCost: -912269,
+        #                grossOpenPremium: 0,
+        #                isOpen: True,
+        #                markPrice: 43772,
+        #                markValue: -913828,
+        #                riskValue: 913828,
+        #                homeNotional: 0.00913828,
+        #                foreignNotional: -400,
+        #                posCost: -912269,
+        #                posCross: 1559,
+        #                posComm: 694,
+        #                posLoss: 0,
+        #                posMargin: 11376,
+        #                posMaint: 3887,
+        #                initMargin: 0,
+        #                maintMargin: 9817,
+        #                realisedPnl: -684,
+        #                unrealisedPnl: -1559,
+        #                unrealisedPnlPcnt: -0.0017,
+        #                unrealisedRoePcnt: -0.1709,
+        #                avgCostPrice: 43846.7643,
+        #                avgEntryPrice: 43846.7643,
+        #                breakEvenPrice: 43880,
+        #                marginCallPrice: 20976,
+        #                liquidationPrice: 20976,
+        #                bankruptPrice: 20941,
+        #                timestamp: '2023-12-07T00:09:00.709Z'
+        #            }
+        #        ]
+        #    }
+        # update
+        #    {
+        #        table: 'position',
+        #        action: 'update',
+        #        data: [
+        #            {
+        #                account: 412475,
+        #                symbol: 'XBTUSD',
+        #                currency: 'XBt',
+        #                currentQty: 400,
+        #                markPrice: 43772.75,
+        #                markValue: -913812,
+        #                riskValue: 913812,
+        #                homeNotional: 0.00913812,
+        #                posCross: 1543,
+        #                posComm: 693,
+        #                posMargin: 11359,
+        #                posMaint: 3886,
+        #                maintMargin: 9816,
+        #                unrealisedPnl: -1543,
+        #                unrealisedRoePcnt: -0.1691,
+        #                liquidationPrice: 20976,
+        #                timestamp: '2023-12-07T00:09:10.760Z'
+        #            }
+        #        ]
+        #    }
+        #
+        if self.positions is None:
+            self.positions = ArrayCacheBySymbolBySide()
+        cache = self.positions
+        rawPositions = self.safe_value(message, 'data', [])
+        newPositions = []
+        for i in range(0, len(rawPositions)):
+            rawPosition = rawPositions[i]
+            position = self.parse_position(rawPosition)
+            newPositions.append(position)
+            cache.append(position)
+        messageHashes = self.find_message_hashes(client, 'positions::')
+        for i in range(0, len(messageHashes)):
+            messageHash = messageHashes[i]
+            parts = messageHash.split('::')
+            symbolsString = parts[1]
+            symbols = symbolsString.split(',')
+            positions = self.filter_by_array(newPositions, 'symbol', symbols, False)
+            if not self.is_empty(positions):
+                client.resolve(positions, messageHash)
+        client.resolve(newPositions, 'positions')
+
     async def watch_orders(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}):
         """
         watches information on multiple orders made by the user
@@ -1318,6 +1515,7 @@ class bitmex(ccxt.async_support.bitmex):
                 'order': self.handle_orders,
                 'execution': self.handle_my_trades,
                 'margin': self.handle_balance,
+                'position': self.handle_positions,
             }
             method = self.safe_value(methods, table)
             if method is None:

ccxt/pro/krakenfutures.py

@@ -102,8 +102,8 @@ class krakenfutures(ccxt.async_support.krakenfutures):
         Connects to a websocket channel
         :param str name: name of the channel
         :param str[] symbols: CCXT market symbols
-        :param Object [params]: extra parameters specific to the krakenfutures api
-        :returns Object: data from the websocket stream
+        :param dict [params]: extra parameters specific to the krakenfutures api
+        :returns dict: data from the websocket stream
         """
         await self.load_markets()
         url = self.urls['api']['ws']
@@ -132,8 +132,8 @@ class krakenfutures(ccxt.async_support.krakenfutures):
         Connects to a websocket channel
         :param str name: name of the channel
         :param str[] symbols: CCXT market symbols
-        :param Object [params]: extra parameters specific to the krakenfutures api
-        :returns Object: data from the websocket stream
+        :param dict [params]: extra parameters specific to the krakenfutures api
+        :returns dict: data from the websocket stream
         """
         await self.load_markets()
         await self.authenticate()

ccxt/pro/mexc.py

@@ -697,7 +697,7 @@ class mexc(ccxt.async_support.mexc):
         :param int [since]: the earliest time in ms to fetch orders for
         :param int [limit]: the maximum number of  orde structures to retrieve
         :param dict [params]: extra parameters specific to the exchange API endpoint
-        :params string|None params.type: the type of orders to retrieve, can be 'spot' or 'margin'
+        :param str|None params['type']: the type of orders to retrieve, can be 'spot' or 'margin'
         :returns dict[]: a list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
         """
         await self.load_markets()

ccxt/pro/poloniex.py

@@ -201,7 +201,7 @@ class poloniex(ccxt.async_support.poloniex):
         :param str [params.stpMode]: self-trade prevention, defaults to expire_taker, none: enable self-trade; expire_taker: taker order will be canceled when self-trade happens
         :param str [params.slippageTolerance]: used to control the maximum slippage ratio, the value range is greater than 0 and less than 1
         :returns dict: an `order structure <https://github.com/ccxt/ccxt/wiki/Manual#order-structure>`
-       """
+        """
         await self.load_markets()
         await self.authenticate()
         market = self.market(symbol)

ccxt/pro/poloniexfutures.py

@@ -130,9 +130,9 @@ class poloniexfutures(ccxt.async_support.poloniexfutures):
         :param str name: name of the channel and suscriptionHash
         :param bool isPrivate: True for the authenticated url, False for the public url
         :param str symbol: is required for all public channels, not required for private channels(except position)
-        :param Object subscription: subscription parameters
-        :param Object [params]: extra parameters specific to the poloniex api
-        :returns Object: data from the websocket stream
+        :param dict subscription: subscription parameters
+        :param dict [params]: extra parameters specific to the poloniex api
+        :returns dict: data from the websocket stream
         """
         url = await self.negotiate(isPrivate)
         if symbol is not None:

ccxt/probit.py

@@ -43,7 +43,10 @@ class probit(Exchange, ImplicitAPI):
                 'option': False,
                 'addMargin': False,
                 'cancelOrder': True,
+                'createMarketBuyOrderWithCost': True,
                 'createMarketOrder': True,
+                'createMarketOrderWithCost': False,
+                'createMarketSellOrderWithCost': False,
                 'createOrder': True,
                 'createReduceOnlyOrder': False,
                 'createStopLimitOrder': False,
@@ -328,6 +331,7 @@ class probit(Exchange, ImplicitAPI):
             'precision': {
                 'amount': self.parse_number(self.parse_precision(self.safe_string(market, 'quantity_precision'))),
                 'price': self.safe_number(market, 'price_increment'),
+                'cost': self.parse_number(self.parse_precision(self.safe_string(market, 'cost_precision'))),
             },
             'limits': {
                 'leverage': {
@@ -1135,14 +1139,15 @@ class probit(Exchange, ImplicitAPI):
 
     def create_order(self, symbol: str, type: OrderType, side: OrderSide, amount, price=None, params={}):
         """
-        :see: https://docs-en.probit.com/reference/order-1
         create a trade order
+        :see: https://docs-en.probit.com/reference/order-1
         :param str symbol: unified symbol of the market to create an order in
         :param str type: 'market' or 'limit'
         :param str side: 'buy' or 'sell'
-        :param float amount: how much of currency you want to trade in units of base currency
+        :param float amount: how much you want to trade in units of the base currency
         :param float [price]: the price at which the order is to be fullfilled, in units of the quote currency, ignored in market orders
         :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param float [params.cost]: the quote quantity that can be used alternative for the amount for market buy orders
         :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """
         self.load_markets()
@@ -1159,27 +1164,30 @@ class probit(Exchange, ImplicitAPI):
         clientOrderId = self.safe_string_2(params, 'clientOrderId', 'client_order_id')
         if clientOrderId is not None:
             request['client_order_id'] = clientOrderId
-        costToPrecision = None
+        quoteAmount = None
         if type == 'limit':
             request['limit_price'] = self.price_to_precision(symbol, price)
             request['quantity'] = self.amount_to_precision(symbol, amount)
         elif type == 'market':
             # for market buy it requires the amount of quote currency to spend
             if side == 'buy':
-                cost = self.safe_number(params, 'cost')
-                createMarketBuyOrderRequiresPrice = self.safe_value(self.options, 'createMarketBuyOrderRequiresPrice', True)
-                if createMarketBuyOrderRequiresPrice:
-                    if price is not None:
-                        if cost is None:
-                            amountString = self.number_to_string(amount)
-                            priceString = self.number_to_string(price)
-                            cost = self.parse_number(Precise.string_mul(amountString, priceString))
-                    elif cost is None:
-                        raise InvalidOrder(self.id + ' createOrder() requires the price argument for market buy orders to calculate total order cost(amount to spend), where cost = amount * price. Supply a price argument to createOrder() call if you want the cost to be calculated for you from price and amount, or, alternatively, add .options["createMarketBuyOrderRequiresPrice"] = False and supply the total cost value in the "amount" argument or in the "cost" extra parameter(the exchange-specific behaviour)')
+                createMarketBuyOrderRequiresPrice = True
+                createMarketBuyOrderRequiresPrice, params = self.handle_option_and_params(params, 'createOrder', 'createMarketBuyOrderRequiresPrice', True)
+                cost = self.safe_string(params, 'cost')
+                params = self.omit(params, 'cost')
+                if cost is not None:
+                    quoteAmount = self.cost_to_precision(symbol, cost)
+                elif createMarketBuyOrderRequiresPrice:
+                    if price is None:
+                        raise InvalidOrder(self.id + ' createOrder() requires the price argument for market buy orders to calculate the total cost to spend(amount * price), alternatively set the createMarketBuyOrderRequiresPrice option or param to False and pass the cost to spend in the amount argument')
+                    else:
+                        amountString = self.number_to_string(amount)
+                        priceString = self.number_to_string(price)
+                        costRequest = Precise.string_mul(amountString, priceString)
+                        quoteAmount = self.cost_to_precision(symbol, costRequest)
                 else:
-                    cost = amount if (cost is None) else cost
-                costToPrecision = self.cost_to_precision(symbol, cost)
-                request['cost'] = costToPrecision
+                    quoteAmount = self.cost_to_precision(symbol, amount)
+                request['cost'] = quoteAmount
             else:
                 request['quantity'] = self.amount_to_precision(symbol, amount)
         query = self.omit(params, ['timeInForce', 'time_in_force', 'clientOrderId', 'client_order_id'])
@@ -1211,7 +1219,7 @@ class probit(Exchange, ImplicitAPI):
         # returned by the exchange on market buys
         if (type == 'market') and (side == 'buy'):
             order['amount'] = None
-            order['cost'] = self.parse_number(costToPrecision)
+            order['cost'] = self.parse_number(quoteAmount)
             order['remaining'] = None
         return order
 

ccxt/tokocrypto.py

@@ -1011,15 +1011,19 @@ class tokocrypto(Exchange, ImplicitAPI):
             responseInner = self.publicGetOpenV1MarketTrades(self.extend(request, params))
             data = self.safe_value(responseInner, 'data', {})
             return self.parse_trades(data, market, since, limit)
+        if limit is not None:
+            request['limit'] = limit  # default = 500, maximum = 1000
         defaultMethod = 'binanceGetTrades'
         method = self.safe_string(self.options, 'fetchTradesMethod', defaultMethod)
+        response = None
         if (method == 'binanceGetAggTrades') and (since is not None):
             request['startTime'] = since
             # https://github.com/ccxt/ccxt/issues/6400
             # https://github.com/binance-exchange/binance-official-api-docs/blob/master/rest-api.md#compressedaggregate-trades-list
             request['endTime'] = self.sum(since, 3600000)
-        if limit is not None:
-            request['limit'] = limit  # default = 500, maximum = 1000
+            response = self.binanceGetAggTrades(self.extend(request, params))
+        else:
+            response = self.binanceGetTrades(self.extend(request, params))
         #
         # Caveats:
         # - default limit(500) applies only if no other parameters set, trades up
@@ -1029,7 +1033,6 @@ class tokocrypto(Exchange, ImplicitAPI):
         # - 'tradeId' accepted and returned by self method is "aggregate" trade id
         #   which is different from actual trade id
         # - setting both fromId and time window results in error
-        response = getattr(self, method)(self.extend(request, params))
         #
         # aggregate trades
         #

{ccxt-4.1.85.dist-info → ccxt-4.1.86.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ccxt
-Version: 4.1.85
+Version: 4.1.86
 Summary: A JavaScript / TypeScript / Python / C# / PHP cryptocurrency trading library with support for 130+ exchanges
 Home-page: https://ccxt.com
 Author: Igor Kroitor
@@ -259,13 +259,13 @@ console.log(version, Object.keys(exchanges));
 
 All-in-one browser bundle (dependencies included), served from a CDN of your choice:
 
-* jsDelivr: https://cdn.jsdelivr.net/npm/ccxt@4.1.85/dist/ccxt.browser.js
-* unpkg: https://unpkg.com/ccxt@4.1.85/dist/ccxt.browser.js
+* jsDelivr: https://cdn.jsdelivr.net/npm/ccxt@4.1.86/dist/ccxt.browser.js
+* unpkg: https://unpkg.com/ccxt@4.1.86/dist/ccxt.browser.js
 
 CDNs are not updated in real-time and may have delays. Defaulting to the most recent version without specifying the version number is not recommended. Please, keep in mind that we are not responsible for the correct operation of those CDN servers.
 
 ```HTML
-<script type="text/javascript" src="https://cdn.jsdelivr.net/npm/ccxt@4.1.85/dist/ccxt.browser.js"></script>
+<script type="text/javascript" src="https://cdn.jsdelivr.net/npm/ccxt@4.1.86/dist/ccxt.browser.js"></script>
 ```
 
 Creates a global `ccxt` object: