ccxt 4.3.69__py2.py3-none-any.whl → 4.3.71__py2.py3-none-any.whl

ccxt/pro/paradex.py

@@ -0,0 +1,340 @@
+# -*- 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 Int, OrderBook, Strings, Ticker, Tickers, Trade
+from ccxt.async_support.base.ws.client import Client
+from typing import List
+
+
+class paradex(ccxt.async_support.paradex):
+
+    def describe(self):
+        return self.deep_extend(super(paradex, self).describe(), {
+            'has': {
+                'ws': True,
+                'watchTicker': True,
+                'watchTickers': True,
+                'watchOrderBook': True,
+                'watchOrders': False,
+                'watchTrades': True,
+                'watchBalance': False,
+                'watchOHLCV': False,
+            },
+            'urls': {
+                'logo': 'https://x.com/tradeparadex/photo',
+                'api': {
+                    'ws': 'wss://ws.api.prod.paradex.trade/v1',
+                },
+                'test': {
+                    'ws': 'wss://ws.api.testnet.paradex.trade/v1',
+                },
+                'www': 'https://www.paradex.trade/',
+                'doc': 'https://docs.api.testnet.paradex.trade/',
+                'fees': 'https://docs.paradex.trade/getting-started/trading-fees',
+                'referral': '',
+            },
+            'options': {},
+            'streaming': {},
+        })
+
+    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://docs.api.testnet.paradex.trade/#sub-trades-market_symbol-operation
+        :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()
+        messageHash = 'trades.'
+        if symbol is not None:
+            market = self.market(symbol)
+            messageHash += market['id']
+        else:
+            messageHash += 'ALL'
+        url = self.urls['api']['ws']
+        request: dict = {
+            'jsonrpc': '2.0',
+            'method': 'subscribe',
+            'params': {
+                'channel': messageHash,
+            },
+        }
+        trades = await self.watch(url, messageHash, self.deep_extend(request, params), messageHash)
+        if self.newUpdates:
+            limit = trades.getLimit(symbol, limit)
+        return self.filter_by_since_limit(trades, since, limit, 'timestamp', True)
+
+    def handle_trade(self, client: Client, message):
+        #
+        #     {
+        #         "jsonrpc": "2.0",
+        #         "method": "subscription",
+        #         "params": {
+        #             "channel": "trades.ALL",
+        #             "data": {
+        #                 "id": "1718179273230201709233240002",
+        #                 "market": "kBONK-USD-PERP",
+        #                 "side": "BUY",
+        #                 "size": "34028",
+        #                 "price": "0.028776",
+        #                 "created_at": 1718179273230,
+        #                 "trade_type": "FILL"
+        #             }
+        #         }
+        #     }
+        #
+        params = self.safe_dict(message, 'params', {})
+        data = self.safe_dict(params, 'data', {})
+        parsedTrade = self.parse_trade(data)
+        symbol = parsedTrade['symbol']
+        messageHash = self.safe_string(params, 'channel')
+        stored = self.safe_value(self.trades, symbol)
+        if stored is None:
+            stored = ArrayCache(self.safe_integer(self.options, 'tradesLimit', 1000))
+            self.trades[symbol] = stored
+        stored.append(parsedTrade)
+        client.resolve(stored, messageHash)
+        return message
+
+    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://docs.api.testnet.paradex.trade/#sub-order_book-market_symbol-snapshot-15-refresh_rate-operation
+        :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
+        :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
+        """
+        market = self.market(symbol)
+        messageHash = 'order_book.' + market['id'] + '.snapshot@15@100ms'
+        url = self.urls['api']['ws']
+        request: dict = {
+            'jsonrpc': '2.0',
+            'method': 'subscribe',
+            'params': {
+                'channel': messageHash,
+            },
+        }
+        orderbook = await self.watch(url, messageHash, self.deep_extend(request, params), messageHash)
+        return orderbook.limit()
+
+    def handle_order_book(self, client: Client, message):
+        #
+        #     {
+        #         "jsonrpc": "2.0",
+        #         "method": "subscription",
+        #         "params": {
+        #             "channel": "order_book.BTC-USD-PERP.snapshot@15@50ms",
+        #             "data": {
+        #                 "seq_no": 14127815,
+        #                 "market": "BTC-USD-PERP",
+        #                 "last_updated_at": 1718267837265,
+        #                 "update_type": "s",
+        #                 "inserts": [
+        #                     {
+        #                         "side": "BUY",
+        #                         "price": "67629.7",
+        #                         "size": "0.992"
+        #                     },
+        #                     {
+        #                         "side": "SELL",
+        #                         "price": "69378.6",
+        #                         "size": "3.137"
+        #                     }
+        #                 ],
+        #                 "updates": [],
+        #                 "deletes": []
+        #             }
+        #         }
+        #     }
+        #
+        params = self.safe_dict(message, 'params', {})
+        data = self.safe_dict(params, 'data', {})
+        marketId = self.safe_string(data, 'market')
+        market = self.safe_market(marketId)
+        timestamp = self.safe_integer(data, 'last_updated_at')
+        symbol = market['symbol']
+        if not (symbol in self.orderbooks):
+            self.orderbooks[symbol] = self.order_book()
+        orderbookData = {
+            'bids': [],
+            'asks': [],
+        }
+        inserts = self.safe_list(data, 'inserts')
+        for i in range(0, len(inserts)):
+            insert = self.safe_dict(inserts, i)
+            side = self.safe_string(insert, 'side')
+            price = self.safe_string(insert, 'price')
+            size = self.safe_string(insert, 'size')
+            if side == 'BUY':
+                orderbookData['bids'].append([price, size])
+            else:
+                orderbookData['asks'].append([price, size])
+        orderbook = self.orderbooks[symbol]
+        snapshot = self.parse_order_book(orderbookData, symbol, timestamp, 'bids', 'asks')
+        snapshot['nonce'] = self.safe_number(data, 'seq_no')
+        orderbook.reset(snapshot)
+        messageHash = self.safe_string(params, 'channel')
+        client.resolve(orderbook, messageHash)
+
+    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://docs.api.testnet.paradex.trade/#sub-markets_summary-operation
+        :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>`
+        """
+        await self.load_markets()
+        symbol = self.symbol(symbol)
+        channel = 'markets_summary'
+        url = self.urls['api']['ws']
+        request: dict = {
+            'jsonrpc': '2.0',
+            'method': 'subscribe',
+            'params': {
+                'channel': channel,
+            },
+        }
+        messageHash = channel + '.' + symbol
+        return await self.watch(url, messageHash, self.deep_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>`
+        """
+        symbols = self.market_symbols(symbols)
+        channel = 'markets_summary'
+        url = self.urls['api']['ws']
+        request: dict = {
+            'jsonrpc': '2.0',
+            'method': 'subscribe',
+            'params': {
+                'channel': channel,
+            },
+        }
+        messageHashes = []
+        if isinstance(symbols, list):
+            for i in range(0, len(symbols)):
+                messageHash = channel + '.' + symbols[i]
+                messageHashes.append(messageHash)
+        else:
+            messageHashes.append(channel)
+        newTickers = await self.watch_multiple(url, messageHashes, self.deep_extend(request, params), messageHashes)
+        if self.newUpdates:
+            result: dict = {}
+            result[newTickers['symbol']] = newTickers
+            return result
+        return self.filter_by_array(self.tickers, 'symbol', symbols)
+
+    def handle_ticker(self, client: Client, message):
+        #
+        #     {
+        #         "jsonrpc": "2.0",
+        #         "method": "subscription",
+        #         "params": {
+        #             "channel": "markets_summary",
+        #             "data": {
+        #                 "symbol": "ORDI-USD-PERP",
+        #                 "oracle_price": "49.80885481",
+        #                 "mark_price": "49.80885481",
+        #                 "last_traded_price": "62.038",
+        #                 "bid": "49.822",
+        #                 "ask": "58.167",
+        #                 "volume_24h": "0",
+        #                 "total_volume": "54542628.66054200416",
+        #                 "created_at": 1718334307698,
+        #                 "underlying_price": "47.93",
+        #                 "open_interest": "6999.5",
+        #                 "funding_rate": "0.03919997509811",
+        #                 "price_change_rate_24h": ""
+        #             }
+        #         }
+        #     }
+        #
+        params = self.safe_dict(message, 'params', {})
+        data = self.safe_dict(params, 'data', {})
+        marketId = self.safe_string(data, 'symbol')
+        market = self.safe_market(marketId)
+        symbol = market['symbol']
+        channel = self.safe_string(params, 'channel')
+        messageHash = channel + '.' + symbol
+        ticker = self.parse_ticker(data, market)
+        self.tickers[symbol] = ticker
+        client.resolve(ticker, channel)
+        client.resolve(ticker, messageHash)
+        return message
+
+    def handle_error_message(self, client: Client, message):
+        #
+        #     {
+        #         "jsonrpc": "2.0",
+        #         "id": 0,
+        #         "error": {
+        #             "code": -32600,
+        #             "message": "invalid subscribe request",
+        #             "data": "invalid channel"
+        #         },
+        #         "usIn": 1718179125962419,
+        #         "usDiff": 76,
+        #         "usOut": 1718179125962495
+        #     }
+        #
+        error = self.safe_dict(message, 'error')
+        if error is None:
+            return True
+        else:
+            errorCode = self.safe_string(error, 'code')
+            if errorCode is not None:
+                feedback = self.id + ' ' + self.json(error)
+                self.throw_exactly_matched_exception(self.exceptions['exact'], '-32600', feedback)
+                messageString = self.safe_value(error, 'message')
+                if messageString is not None:
+                    self.throw_broadly_matched_exception(self.exceptions['broad'], messageString, feedback)
+            return False
+
+    def handle_message(self, client: Client, message):
+        if not self.handle_error_message(client, message):
+            return
+        #
+        #     {
+        #         "jsonrpc": "2.0",
+        #         "method": "subscription",
+        #         "params": {
+        #             "channel": "trades.ALL",
+        #             "data": {
+        #                 "id": "1718179273230201709233240002",
+        #                 "market": "kBONK-USD-PERP",
+        #                 "side": "BUY",
+        #                 "size": "34028",
+        #                 "price": "0.028776",
+        #                 "created_at": 1718179273230,
+        #                 "trade_type": "FILL"
+        #             }
+        #         }
+        #     }
+        #
+        data = self.safe_dict(message, 'params')
+        if data is not None:
+            channel = self.safe_string(data, 'channel')
+            parts = channel.split('.')
+            name = self.safe_string(parts, 0)
+            methods: dict = {
+                'trades': self.handle_trade,
+                'order_book': self.handle_order_book,
+                'markets_summary': self.handle_ticker,
+                # ...
+            }
+            method = self.safe_value(methods, name)
+            if method is not None:
+                method(client, message)

ccxt/pro/poloniex.py

@@ -1100,13 +1100,7 @@ class poloniex(ccxt.async_support.poloniex):
         if type == 'auth':
             self.handle_authenticate(client, message)
         elif type is None:
-            data = self.safe_value(message, 'data')
-            item = self.safe_value(data, 0)
-            orderId = self.safe_string(item, 'orderId')
-            if orderId == '0':
-                self.handle_error_message(client, item)
-            else:
-                self.handle_order_request(client, message)
+            self.handle_order_request(client, message)
         else:
             data = self.safe_value(message, 'data', [])
             dataLength = len(data)
@@ -1131,12 +1125,40 @@ class poloniex(ccxt.async_support.poloniex):
         #       "event": "error",
         #       "message": "Platform in maintenance mode"
         #    }
+        #    {
+        #       "id":"1722386782048",
+        #       "data":[
+        #          {
+        #             "orderId":0,
+        #             "clientOrderId":null,
+        #             "message":"available insufficient",
+        #             "code":21721
+        #          }
+        #       ]
+        #    }
         #
+        id = self.safe_string(message, 'id')
         event = self.safe_string(message, 'event')
-        orderId = self.safe_string(message, 'orderId')
+        data = self.safe_list(message, 'data')
+        first = self.safe_dict(data, 0)
+        orderId = self.safe_string(first, 'orderId')
         if (event == 'error') or (orderId == '0'):
-            error = self.safe_string(message, 'message')
-            raise ExchangeError(self.id + ' error: ' + self.json(error))
+            try:
+                error = self.safe_string(first, 'message')
+                code = self.safe_string(first, 'code')
+                feedback = self.id + ' ' + self.json(message)
+                self.throw_exactly_matched_exception(self.exceptions['exact'], code, feedback)
+                self.throw_broadly_matched_exception(self.exceptions['broad'], error, feedback)
+                raise ExchangeError(feedback)
+            except Exception as e:
+                if isinstance(e, AuthenticationError):
+                    messageHash = 'authenticated'
+                    client.reject(e, messageHash)
+                    if messageHash in client.subscriptions:
+                        del client.subscriptions[messageHash]
+                else:
+                    client.reject(e, id)
+                return True
         return False
 
     def handle_authenticate(self, client: Client, message):

ccxt/pro/woo.py

@@ -34,7 +34,7 @@ class woo(ccxt.async_support.woo):
                 'api': {
                     'ws': {
                         'public': 'wss://wss.woo.org/ws/stream',
-                        'private': 'wss://wss.woo.network/v2/ws/private/stream',
+                        'private': 'wss://wss.woo.org/v2/ws/private/stream',
                     },
                 },
                 'test': {
@@ -79,7 +79,8 @@ class woo(ccxt.async_support.woo):
         return newValue
 
     async def watch_public(self, messageHash, message):
-        url = self.urls['api']['ws']['public'] + '/' + self.uid
+        urlUid = '/' + self.uid if (self.uid) else ''
+        url = self.urls['api']['ws']['public'] + urlUid
         requestId = self.request_id(url)
         subscribe: dict = {
             'id': requestId,
@@ -456,7 +457,7 @@ class woo(ccxt.async_support.woo):
         marketId = self.safe_string(trade, 'symbol')
         market = self.safe_market(marketId, market)
         symbol = market['symbol']
-        price = self.safe_string(trade, 'executedPrice', 'price')
+        price = self.safe_string_2(trade, 'executedPrice', 'price')
         amount = self.safe_string_2(trade, 'executedQuantity', 'size')
         cost = Precise.string_mul(price, amount)
         side = self.safe_string_lower(trade, 'side')
@@ -492,7 +493,7 @@ class woo(ccxt.async_support.woo):
     def check_required_uid(self, error=True):
         if not self.uid:
             if error:
-                raise AuthenticationError(self.id + ' requires `uid` credential')
+                raise AuthenticationError(self.id + ' requires `uid` credential(woox calls it `application_id`)')
             else:
                 return False
         return True

ccxt/static_dependencies/__init__.py

@@ -1 +1 @@
-__all__ = ['ecdsa', 'keccak', 'aiohttp_socks', 'ethereum', 'parsimonious', 'toolz']
+__all__ = ['ecdsa', 'keccak', 'aiohttp_socks', 'ethereum', 'parsimonious', 'toolz', 'starknet', 'marshmallow', 'marshmallow_oneofschema', 'lark', 'starkware', 'sympy']

ccxt/static_dependencies/lark/__init__.py

@@ -0,0 +1,38 @@
+from .exceptions import (
+    GrammarError,
+    LarkError,
+    LexError,
+    ParseError,
+    UnexpectedCharacters,
+    UnexpectedEOF,
+    UnexpectedInput,
+    UnexpectedToken,
+)
+from .lark import Lark
+from .lexer import Token
+from .tree import ParseTree, Tree
+from .utils import logger
+from .visitors import Discard, Transformer, Transformer_NonRecursive, Visitor, v_args
+
+__version__: str = "1.2.0"
+
+__all__ = (
+    "GrammarError",
+    "LarkError",
+    "LexError",
+    "ParseError",
+    "UnexpectedCharacters",
+    "UnexpectedEOF",
+    "UnexpectedInput",
+    "UnexpectedToken",
+    "Lark",
+    "Token",
+    "ParseTree",
+    "Tree",
+    "logger",
+    "Discard",
+    "Transformer",
+    "Transformer_NonRecursive",
+    "Visitor",
+    "v_args",
+)

ccxt/static_dependencies/lark/__pyinstaller/__init__.py

@@ -0,0 +1,6 @@
+# For usage of lark with PyInstaller. See https://pyinstaller-sample-hook.readthedocs.io/en/latest/index.html
+
+import os
+
+def get_hook_dirs():
+    return [os.path.dirname(__file__)]

ccxt/static_dependencies/lark/__pyinstaller/hook-lark.py

@@ -0,0 +1,14 @@
+#-----------------------------------------------------------------------------
+# Copyright (c) 2017-2020, PyInstaller Development Team.
+#
+# Distributed under the terms of the GNU General Public License (version 2
+# or later) with exception for distributing the bootloader.
+#
+# The full license is in the file COPYING.txt, distributed with this software.
+#
+# SPDX-License-Identifier: (GPL-2.0-or-later WITH Bootloader-exception)
+#-----------------------------------------------------------------------------
+
+from PyInstaller.utils.hooks import collect_data_files
+
+datas = collect_data_files('lark')

ccxt/static_dependencies/lark/ast_utils.py

@@ -0,0 +1,59 @@
+"""
+    Module of utilities for transforming a lark.Tree into a custom Abstract Syntax Tree (AST defined in classes)
+"""
+
+import inspect, re
+import types
+from typing import Optional, Callable
+
+from lark import Transformer, v_args
+
+class Ast:
+    """Abstract class
+
+    Subclasses will be collected by `create_transformer()`
+    """
+    pass
+
+class AsList:
+    """Abstract class
+
+    Subclasses will be instantiated with the parse results as a single list, instead of as arguments.
+    """
+
+class WithMeta:
+    """Abstract class
+
+    Subclasses will be instantiated with the Meta instance of the tree. (see ``v_args`` for more detail)
+    """
+    pass
+
+def camel_to_snake(name):
+    return re.sub(r'(?<!^)(?=[A-Z])', '_', name).lower()
+
+def create_transformer(ast_module: types.ModuleType,
+                       transformer: Optional[Transformer]=None,
+                       decorator_factory: Callable=v_args) -> Transformer:
+    """Collects `Ast` subclasses from the given module, and creates a Lark transformer that builds the AST.
+
+    For each class, we create a corresponding rule in the transformer, with a matching name.
+    CamelCase names will be converted into snake_case. Example: "CodeBlock" -> "code_block".
+
+    Classes starting with an underscore (`_`) will be skipped.
+
+    Parameters:
+        ast_module: A Python module containing all the subclasses of ``ast_utils.Ast``
+        transformer (Optional[Transformer]): An initial transformer. Its attributes may be overwritten.
+        decorator_factory (Callable): An optional callable accepting two booleans, inline, and meta,
+            and returning a decorator for the methods of ``transformer``. (default: ``v_args``).
+    """
+    t = transformer or Transformer()
+
+    for name, obj in inspect.getmembers(ast_module):
+        if not name.startswith('_') and inspect.isclass(obj):
+            if issubclass(obj, Ast):
+                wrapper = decorator_factory(inline=not issubclass(obj, AsList), meta=issubclass(obj, WithMeta))
+                obj = wrapper(obj).__get__(t)
+                setattr(t, camel_to_snake(name), obj)
+
+    return t

ccxt/static_dependencies/lark/common.py

@@ -0,0 +1,86 @@
+from copy import deepcopy
+import sys
+from types import ModuleType
+from typing import Callable, Collection, Dict, Optional, TYPE_CHECKING, List
+
+if TYPE_CHECKING:
+    from .lark import PostLex
+    from .lexer import Lexer
+    from .grammar import Rule
+    from typing import Union, Type
+    from typing import Literal
+    if sys.version_info >= (3, 10):
+        from typing import TypeAlias
+    else:
+        from typing_extensions import TypeAlias
+
+from .utils import Serialize
+from .lexer import TerminalDef, Token
+
+###{standalone
+
+_ParserArgType: 'TypeAlias' = 'Literal["earley", "lalr", "cyk", "auto"]'
+_LexerArgType: 'TypeAlias' = 'Union[Literal["auto", "basic", "contextual", "dynamic", "dynamic_complete"], Type[Lexer]]'
+_LexerCallback = Callable[[Token], Token]
+ParserCallbacks = Dict[str, Callable]
+
+class LexerConf(Serialize):
+    __serialize_fields__ = 'terminals', 'ignore', 'g_regex_flags', 'use_bytes', 'lexer_type'
+    __serialize_namespace__ = TerminalDef,
+
+    terminals: Collection[TerminalDef]
+    re_module: ModuleType
+    ignore: Collection[str]
+    postlex: 'Optional[PostLex]'
+    callbacks: Dict[str, _LexerCallback]
+    g_regex_flags: int
+    skip_validation: bool
+    use_bytes: bool
+    lexer_type: Optional[_LexerArgType]
+    strict: bool
+
+    def __init__(self, terminals: Collection[TerminalDef], re_module: ModuleType, ignore: Collection[str]=(), postlex: 'Optional[PostLex]'=None,
+                 callbacks: Optional[Dict[str, _LexerCallback]]=None, g_regex_flags: int=0, skip_validation: bool=False, use_bytes: bool=False, strict: bool=False):
+        self.terminals = terminals
+        self.terminals_by_name = {t.name: t for t in self.terminals}
+        assert len(self.terminals) == len(self.terminals_by_name)
+        self.ignore = ignore
+        self.postlex = postlex
+        self.callbacks = callbacks or {}
+        self.g_regex_flags = g_regex_flags
+        self.re_module = re_module
+        self.skip_validation = skip_validation
+        self.use_bytes = use_bytes
+        self.strict = strict
+        self.lexer_type = None
+
+    def _deserialize(self):
+        self.terminals_by_name = {t.name: t for t in self.terminals}
+
+    def __deepcopy__(self, memo=None):
+        return type(self)(
+            deepcopy(self.terminals, memo),
+            self.re_module,
+            deepcopy(self.ignore, memo),
+            deepcopy(self.postlex, memo),
+            deepcopy(self.callbacks, memo),
+            deepcopy(self.g_regex_flags, memo),
+            deepcopy(self.skip_validation, memo),
+            deepcopy(self.use_bytes, memo),
+        )
+
+class ParserConf(Serialize):
+    __serialize_fields__ = 'rules', 'start', 'parser_type'
+
+    rules: List['Rule']
+    callbacks: ParserCallbacks
+    start: List[str]
+    parser_type: _ParserArgType
+
+    def __init__(self, rules: List['Rule'], callbacks: ParserCallbacks, start: List[str]):
+        assert isinstance(start, list)
+        self.rules = rules
+        self.callbacks = callbacks
+        self.start = start
+
+###}