ccxt 4.1.54__py2.py3-none-any.whl → 4.1.56__py2.py3-none-any.whl

ccxt/base/types.py

@@ -10,7 +10,6 @@ else:
     from typing_extensions import Literal
     TypedDict = Dict
 
-
 OrderSide = Literal['buy', 'sell']
 OrderType = Literal['limit', 'market']
 PositionSide = Literal['long', 'short']
@@ -40,8 +39,8 @@ class Entry:
 
 
 IndexType = Union[str, int]
-Numeric = Union[None, str, float, int, Decimal]
-String = Optional[str]
+Num = Union[None, str, float, int, Decimal]
+Str = Optional[str]
 Strings = Optional[List[str]]
 Int = Optional[int]
 Bool = Optional[bool]
@@ -49,61 +48,61 @@ Fee = Optional[Dict[str, Any]]
 
 
 class Balance(TypedDict):
-    free: Numeric
-    used: Numeric
-    total: Numeric
+    free: Num
+    used: Num
+    total: Num
 
 
 class Trade(TypedDict):
     info: Dict[str, Any]
-    amount: Numeric
-    datetime: String
-    id: String
-    order: String
-    price: Numeric
+    amount: Num
+    datetime: Str
+    id: Str
+    order: Str
+    price: Num
     timestamp: Int
-    type: String
-    side: String
-    symbol: String
-    takerOrMaker: String
-    cost: Numeric
+    type: Str
+    side: Str
+    symbol: Str
+    takerOrMaker: Str
+    cost: Num
     fee: Fee
 
 
 class Position(TypedDict):
     info: Dict[str, Any]
-    symbol: String
-    id: String
+    symbol: Str
+    id: Str
     timestamp: Int
-    datetime: String
-    contracts: Numeric
-    contractSize: Numeric
-    side: String
-    notional: Numeric
-    leverage: Numeric
-    unrealizedPnl: Numeric
-    realizedPnl: Numeric
-    collateral: Numeric
-    entryPrice: Numeric
-    markPrice: Numeric
-    liquidationPrice: Numeric
+    datetime: Str
+    contracts: Num
+    contractSize: Num
+    side: Str
+    notional: Num
+    leverage: Num
+    unrealizedPnl: Num
+    realizedPnl: Num
+    collateral: Num
+    entryPrice: Num
+    markPrice: Num
+    liquidationPrice: Num
     hedged: bool
-    maintenanceMargin: Numeric
-    initialMargin: Numeric
-    initialMarginPercentage: Numeric
-    marginMode: String
-    marginRatio: Numeric
+    maintenanceMargin: Num
+    initialMargin: Num
+    initialMarginPercentage: Num
+    marginMode: Str
+    marginRatio: Num
     lastUpdateTimestamp: Int
-    lastPrice: Numeric
-    percentage: Numeric
-    stopLossPrice: Numeric
-    takeProfitPrice: Numeric
+    lastPrice: Num
+    percentage: Num
+    stopLossPrice: Num
+    takeProfitPrice: Num
 
 
 class OrderRequest(TypedDict):
-    symbol: String
-    type: String
-    side: String
+    symbol: Str
+    type: Str
+    side: Str
     amount: Union[None, float]
     price: Union[None, float]
     params: Dict[str, Any]
@@ -111,97 +110,97 @@ class OrderRequest(TypedDict):
 
 class Order(TypedDict):
     info: Dict[str, Any]
-    id: String
-    clientOrderId: String
-    datetime: String
+    id: Str
+    clientOrderId: Str
+    datetime: Str
     timestamp: Int
     lastTradeTimestamp: Int
     lastUpdateTimestamp: Int
-    status: String
-    symbol: String
-    type: String
-    timeInForce: String
+    status: Str
+    symbol: Str
+    type: Str
+    timeInForce: Str
     side: OrderSide
-    price: Numeric
-    average: Numeric
-    amount: Numeric
-    filled: Numeric
-    remaining: Numeric
-    stopPrice: Numeric
-    takeProfitPrice: Numeric
-    stopLossPrice: Numeric
-    cost: Numeric
+    price: Num
+    average: Num
+    amount: Num
+    filled: Num
+    remaining: Num
+    stopPrice: Num
+    takeProfitPrice: Num
+    stopLossPrice: Num
+    cost: Num
     trades: List[Trade]
     fee: Fee
 
 
 class FundingHistory(TypedDict):
     info: Dict[str, Any]
-    symbol: String
-    code: String
+    symbol: Str
+    code: Str
     timestamp: Int
-    datetime: String
-    id: String
-    amount: Numeric
+    datetime: Str
+    id: Str
+    amount: Num
 
 
 class Balances(Dict[str, Balance]):
-    datetime: String
+    datetime: Str
     timestamp: Int
 
 
 class OrderBook(TypedDict):
-    asks: List[Numeric]
-    bids: List[Numeric]
-    datetime: String
+    asks: List[Num]
+    bids: List[Num]
+    datetime: Str
     timestamp: Int
     nonce: Int
 
 
 class Transaction(TypedDict):
     info: Dict[str, any]
-    id: String
-    txid: String
+    id: Str
+    txid: Str
     timestamp: Int
-    datetime: String
-    address: String
-    addressFrom: String
-    addressTo: String
-    tag: String
-    tagFrom: String
-    tagTo: String
-    type: String
-    amount: Numeric
-    currency: String
-    status: String
+    datetime: Str
+    address: Str
+    addressFrom: Str
+    addressTo: Str
+    tag: Str
+    tagFrom: Str
+    tagTo: Str
+    type: Str
+    amount: Num
+    currency: Str
+    status: Str
     updated: Int
     fee: Fee
-    network: String
-    comment: String
+    network: Str
+    comment: Str
     internal: Bool
 
 
 class Ticker(TypedDict):
     info: Dict[str, Any]
-    symbol: String
+    symbol: Str
     timestamp: Int
-    datetime: String
-    high: Numeric
-    low: Numeric
-    bid: Numeric
-    bidVolume: Numeric
-    ask: Numeric
-    askVolume: Numeric
-    vwap: Numeric
-    open: Numeric
-    close: Numeric
-    last: Numeric
-    previousClose: Numeric
-    change: Numeric
-    percentage: Numeric
-    average: Numeric
-    quoteVolume: Numeric
-    baseVolume: Numeric
+    datetime: Str
+    high: Num
+    low: Num
+    bid: Num
+    bidVolume: Num
+    ask: Num
+    askVolume: Num
+    vwap: Num
+    open: Num
+    close: Num
+    last: Num
+    previousClose: Num
+    change: Num
+    percentage: Num
+    average: Num
+    quoteVolume: Num
+    baseVolume: Num
 
 
 Tickers = Dict[str, Ticker]
@@ -209,71 +208,71 @@ Tickers = Dict[str, Ticker]
 
 class MarginMode(TypedDict):
     info: Dict[str, Any]
-    symbol: String
-    marginMode: String
+    symbol: Str
+    marginMode: Str
 
 
 class Greeks(TypedDict):
-    symbol: String
+    symbol: Str
     timestamp: Int
-    datetime: String
-    delta: Numeric
-    gamma: Numeric
-    theta: Numeric
-    vega: Numeric
-    rho: Numeric
-    bidSize: Numeric
-    askSize: Numeric
-    bidImpliedVolatility: Numeric
-    askImpliedVolatility: Numeric
-    markImpliedVolatility: Numeric
-    bidPrice: Numeric
-    askPrice: Numeric
-    markPrice: Numeric
-    lastPrice: Numeric
-    underlyingPrice: Numeric
+    datetime: Str
+    delta: Num
+    gamma: Num
+    theta: Num
+    vega: Num
+    rho: Num
+    bidSize: Num
+    askSize: Num
+    bidImpliedVolatility: Num
+    askImpliedVolatility: Num
+    markImpliedVolatility: Num
+    bidPrice: Num
+    askPrice: Num
+    markPrice: Num
+    lastPrice: Num
+    underlyingPrice: Num
     info: Dict[str, Any]
 
 
 class MarketInterface(TypedDict):
     info: Dict[str, Any]
-    id: String
-    symbol: String
-    base: String
-    quote: String
-    baseId: String
-    quoteId: String
+    id: Str
+    symbol: Str
+    base: Str
+    quote: Str
+    baseId: Str
+    quoteId: Str
     active: Bool
-    type: String
+    type: Str
     spot: bool
     margin: bool
     swap: bool
     future: bool
     option: bool
     contract: bool
-    settle: String
-    settleId: String
-    contractSize: Numeric
+    settle: Str
+    settleId: Str
+    contractSize: Num
     linear: bool
     inverse: bool
-    expiry: Numeric
-    expiryDatetime: String
-    strike: Numeric
-    optionType: String
-    taker: Numeric
-    maker: Numeric
+    expiry: Num
+    expiryDatetime: Str
+    strike: Num
+    optionType: Str
+    taker: Num
+    maker: Num
     percentage: bool
     tierBased: bool
-    feeSide: String
+    feeSide: Str
     precision: Any
     limits: Any
     created: Int
 
 
 class CurrencyInterface(TypedDict):
-    id: String
-    code: String
-    precision: Numeric
+    id: Str
+    code: Str
+    precision: Num
 
 
 Market = Optional[MarketInterface]

ccxt/bigone.py

@@ -5,7 +5,7 @@
 
 from ccxt.base.exchange import Exchange
 from ccxt.abstract.bigone import ImplicitAPI
-from ccxt.base.types import Balances, Int, Market, Order, OrderBook, OrderSide, OrderType, String, Strings, Ticker, Tickers, Trade, Transaction
+from ccxt.base.types import Balances, Currency, Int, Market, Order, OrderBook, OrderSide, OrderType, Str, Bool, Strings, Ticker, Tickers, Trade, Transaction
 from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import PermissionDenied
@@ -414,8 +414,8 @@ class bigone(Exchange, ImplicitAPI):
             networks = {}
             chains = self.safe_value(currency, 'binding_gateways', [])
             currencyMaxPrecision = self.parse_precision(self.safe_string_2(currency, 'withdrawal_scale', 'scale'))
-            currencyDepositEnabled = None
-            currencyWithdrawEnabled = None
+            currencyDepositEnabled: Bool = None
+            currencyWithdrawEnabled: Bool = None
             for j in range(0, len(chains)):
                 chain = chains[j]
                 networkId = self.safe_string(chain, 'gateway_name')
@@ -570,7 +570,7 @@ class bigone(Exchange, ImplicitAPI):
             'info': market,
         }
 
-    def parse_ticker(self, ticker, market=None) -> Ticker:
+    def parse_ticker(self, ticker, market: Market = None) -> Ticker:
         #
         #     {
         #         "asset_pair_name":"ETH-BTC",
@@ -747,7 +747,7 @@ class bigone(Exchange, ImplicitAPI):
         orderbook = self.safe_value(response, 'data', {})
         return self.parse_order_book(orderbook, market['symbol'], None, 'bids', 'asks', 'price', 'quantity')
 
-    def parse_trade(self, trade, market=None) -> Trade:
+    def parse_trade(self, trade, market: Market = None) -> Trade:
         #
         # fetchTrades(public)
         #
@@ -796,7 +796,7 @@ class bigone(Exchange, ImplicitAPI):
         market = self.safe_market(marketId, market, '-')
         side = self.safe_string(trade, 'side')
         takerSide = self.safe_string(trade, 'taker_side')
-        takerOrMaker = None
+        takerOrMaker: Str = None
         if (takerSide is not None) and (side is not None) and (side != 'SELF_TRADING'):
             takerOrMaker = 'taker' if (takerSide == side) else 'maker'
         if side is None:
@@ -810,12 +810,9 @@ class bigone(Exchange, ImplicitAPI):
                 side = 'sell'
         makerOrderId = self.safe_string(trade, 'maker_order_id')
         takerOrderId = self.safe_string(trade, 'taker_order_id')
-        orderId = None
+        orderId: Str = None
         if makerOrderId is not None:
-            if takerOrderId is not None:
-                orderId = [makerOrderId, takerOrderId]
-            else:
-                orderId = makerOrderId
+            orderId = makerOrderId
         elif takerOrderId is not None:
             orderId = takerOrderId
         id = self.safe_string(trade, 'id')
@@ -912,7 +909,7 @@ class bigone(Exchange, ImplicitAPI):
         trades = self.safe_value(response, 'data', [])
         return self.parse_trades(trades, market, since, limit)
 
-    def parse_ohlcv(self, ohlcv, market=None) -> list:
+    def parse_ohlcv(self, ohlcv, market: Market = None) -> list:
         #
         #     {
         #         "close": "0.021562",
@@ -1035,7 +1032,7 @@ class bigone(Exchange, ImplicitAPI):
         }
         return self.safe_string(types, type, type)
 
-    def parse_order(self, order, market=None) -> Order:
+    def parse_order(self, order, market: Market = None) -> Order:
         #
         #    {
         #        "id": "42154072251",
@@ -1189,7 +1186,7 @@ class bigone(Exchange, ImplicitAPI):
         order = self.safe_value(response, 'data')
         return self.parse_order(order, market)
 
-    def cancel_order(self, id: str, symbol: String = None, params={}):
+    def cancel_order(self, id: str, symbol: Str = None, params={}):
         """
         cancels an open order
         :param str id: order id
@@ -1215,7 +1212,7 @@ class bigone(Exchange, ImplicitAPI):
         order = self.safe_value(response, 'data')
         return self.parse_order(order)
 
-    def cancel_all_orders(self, symbol: String = None, params={}):
+    def cancel_all_orders(self, symbol: Str = None, params={}):
         """
         cancel all open orders
         :param str symbol: unified market symbol, only orders in the market of self symbol are cancelled when symbol is not None
@@ -1242,7 +1239,7 @@ class bigone(Exchange, ImplicitAPI):
         #
         return response
 
-    def fetch_order(self, id: str, symbol: String = None, params={}):
+    def fetch_order(self, id: str, symbol: Str = None, params={}):
         """
         fetches information on an order made by the user
         :param str symbol: not used by bigone fetchOrder
@@ -1255,7 +1252,7 @@ class bigone(Exchange, ImplicitAPI):
         order = self.safe_value(response, 'data', {})
         return self.parse_order(order)
 
-    def fetch_orders(self, symbol: String = None, since: Int = None, limit: Int = None, params={}) -> List[Order]:
+    def fetch_orders(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Order]:
         """
         fetches information on multiple orders made by the user
         :param str symbol: unified market symbol of the market orders were made in
@@ -1300,7 +1297,7 @@ class bigone(Exchange, ImplicitAPI):
         orders = self.safe_value(response, 'data', [])
         return self.parse_orders(orders, market, since, limit)
 
-    def fetch_my_trades(self, symbol: String = None, since: Int = None, limit: Int = None, params={}):
+    def fetch_my_trades(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}):
         """
         fetch all trades made by the user
         :param str symbol: unified market symbol
@@ -1364,7 +1361,7 @@ class bigone(Exchange, ImplicitAPI):
         }
         return self.safe_string(statuses, status)
 
-    def fetch_open_orders(self, symbol: String = None, since: Int = None, limit: Int = None, params={}) -> List[Order]:
+    def fetch_open_orders(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Order]:
         """
         fetch all unfilled currently open orders
         :param str symbol: unified market symbol
@@ -1378,7 +1375,7 @@ class bigone(Exchange, ImplicitAPI):
         }
         return self.fetch_orders(symbol, since, limit, self.extend(request, params))
 
-    def fetch_closed_orders(self, symbol: String = None, since: Int = None, limit: Int = None, params={}) -> List[Order]:
+    def fetch_closed_orders(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Order]:
         """
         fetches information on multiple closed orders made by the user
         :param str symbol: unified market symbol of the market orders were made in
@@ -1484,7 +1481,7 @@ class bigone(Exchange, ImplicitAPI):
         }
         return self.safe_string(statuses, status, status)
 
-    def parse_transaction(self, transaction, currency=None) -> Transaction:
+    def parse_transaction(self, transaction, currency: Currency = None) -> Transaction:
         #
         # fetchDeposits
         #
@@ -1571,7 +1568,7 @@ class bigone(Exchange, ImplicitAPI):
             'internal': internal,
         }
 
-    def fetch_deposits(self, code: String = None, since: Int = None, limit: Int = None, params={}) -> List[Transaction]:
+    def fetch_deposits(self, code: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Transaction]:
         """
         fetch all deposits made to an account
         :param str code: unified currency code
@@ -1618,7 +1615,7 @@ class bigone(Exchange, ImplicitAPI):
         deposits = self.safe_value(response, 'data', [])
         return self.parse_transactions(deposits, currency, since, limit)
 
-    def fetch_withdrawals(self, code: String = None, since: Int = None, limit: Int = None, params={}) -> List[Transaction]:
+    def fetch_withdrawals(self, code: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Transaction]:
         """
         fetch all withdrawals made from an account
         :param str code: unified currency code
@@ -1708,7 +1705,7 @@ class bigone(Exchange, ImplicitAPI):
             transfer['id'] = guid
         return transfer
 
-    def parse_transfer(self, transfer, currency=None):
+    def parse_transfer(self, transfer, currency: Currency = None):
         #
         #     {
         #         "code": 0,