ccxt-ir 4.3.46.0.2__py2.py3-none-any.whl → 4.5.0__py2.py3-none-any.whl

ccxt/async_support/bitir.py

@@ -5,17 +5,17 @@
 
 from ccxt.async_support.base.exchange import Exchange
 from ccxt.abstract.bitir import ImplicitAPI
-from ccxt.base.types import Int, Market, OrderBook, Strings, Ticker, Tickers
+from ccxt.base.types import Any, Int, Market, OrderBook, Strings, Ticker, Tickers
 from typing import List
 
 
 class bitir(Exchange, ImplicitAPI):
 
-    def describe(self):
+    def describe(self) -> Any:
         return self.deep_extend(super(bitir, self).describe(), {
             'id': 'bitir',
             'name': 'Bit.ir',
-            'country': ['IR'],
+            'countries': ['IR'],
             'rateLimit': 1000,
             'version': '1',
             'certified': False,
@@ -126,10 +126,10 @@ class bitir(Exchange, ImplicitAPI):
             },
         })
 
-    async def fetch_markets(self, symbols: Strings = None, params={}) -> List[Market]:
+    async def fetch_markets(self, params={}) -> List[Market]:
         """
         retrieves data on all markets for bitir
-        :see: https://www.bit.ir/fa
+        https://www.bit.ir/fa
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict[]: an array of objects representing market data
         """
@@ -137,7 +137,7 @@ class bitir(Exchange, ImplicitAPI):
         markets = self.safe_list(response, 'data')
         result = []
         for i in range(0, len(markets)):
-            market = await self.parse_market(markets[i])
+            market = self.parse_market(markets[i])
             result.append(market)
         return result
 
@@ -257,7 +257,7 @@ class bitir(Exchange, ImplicitAPI):
     async def fetch_tickers(self, symbols: Strings = None, params={}) -> Tickers:
         """
         fetches price tickers for multiple markets, statistical information calculated over the past 24 hours for each market
-        :see: https://www.bit.ir/fa
+        https://www.bit.ir/fa
         :param str[]|None symbols: unified symbols of the markets to fetch the ticker for, all market tickers are returned if not assigned
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: a dictionary of `ticker structures <https://docs.ccxt.com/#/?id=ticker-structure>`
@@ -269,7 +269,7 @@ class bitir(Exchange, ImplicitAPI):
         markets = self.safe_list(response, 'data')
         result = []
         for i in range(0, len(markets)):
-            ticker = await self.parse_ticker(markets[i])
+            ticker = self.parse_ticker(markets[i])
             symbol = ticker['symbol']
             result[symbol] = ticker
         return self.filter_by_array_tickers(result, 'symbol', symbols)
@@ -277,7 +277,7 @@ class bitir(Exchange, ImplicitAPI):
     async def fetch_ticker(self, symbol: str, params={}) -> Ticker:
         """
         fetches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
-        :see: https://www.bit.ir/fa
+        https://www.bit.ir/fa
         :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>`
@@ -289,7 +289,7 @@ class bitir(Exchange, ImplicitAPI):
         }
         response = await self.publicGetV1Market(request)
         markets = self.safe_dict(response, 'data')
-        ticker = await self.parse_ticker(markets)
+        ticker = self.parse_ticker(markets)
         return ticker
 
     def parse_ticker(self, ticker, market: Market = None) -> Ticker:
@@ -350,24 +350,24 @@ class bitir(Exchange, ImplicitAPI):
         marketId = self.safe_string(ticker, 'id')
         marketinfo = self.market(marketId)
         symbol = self.safe_symbol(marketId, market, None, marketType)
-        high = self.safe_float(ticker, 'max_price')
-        low = self.safe_float(ticker, 'min_price')
-        bid = self.safe_float(ticker, 'min_price')
-        ask = self.safe_float(ticker, 'max_price')
-        open = self.safe_float(ticker, 'last_price')
-        close = self.safe_float(ticker, 'last_price')
-        change = self.safe_float(ticker, 'day_change_percent')
-        last = self.safe_float(ticker, 'last_price')
-        quoteVolume = self.safe_float(ticker, 'last_volume')
+        high = self.safe_float(ticker, 'max_price', 0)
+        low = self.safe_float(ticker, 'min_price', 0)
+        bid = self.safe_float(ticker, 'min_price', 0)
+        ask = self.safe_float(ticker, 'max_price', 0)
+        open = self.safe_float(ticker, 'last_price', 0)
+        close = self.safe_float(ticker, 'last_price', 0)
+        change = self.safe_float(ticker, 'day_change_percent', 0)
+        last = self.safe_float(ticker, 'last_price', 0)
+        quoteVolume = self.safe_float(ticker, 'last_volume', 0)
         if marketinfo['quote'] == 'IRT':
-            high /= 10
-            low /= 10
-            bid /= 10
-            ask /= 10
-            open /= 10
-            close /= 10
-            last /= 10
-            quoteVolume /= 10
+            high = high / 10 if high else 0
+            low = low / 10 if low else 0
+            bid = bid / 10 if bid else 0
+            ask = ask / 10 if ask else 0
+            open = open / 10 if open else 0
+            close = close / 10 if close else 0
+            last = last / 10 if last else 0
+            quoteVolume = quoteVolume / 10 if quoteVolume else 0
         return self.safe_ticker({
             'symbol': symbol,
             'timestamp': None,
@@ -394,7 +394,7 @@ class bitir(Exchange, ImplicitAPI):
     async def fetch_ohlcv(self, symbol: str, timeframe='1h', since: Int = None, limit: Int = None, params={}) -> List[list]:
         """
         fetches historical candlestick data containing the open, high, low, and close price, and the volume of a market
-        :see: https://www.bit.ir/fa
+        https://www.bit.ir/fa
         :param str symbol: unified symbol of the market to fetch OHLCV data for
         :param str timeframe: the length of time each candle represents
         :param int [since]: timestamp in ms of the earliest candle to fetch
@@ -430,11 +430,11 @@ class bitir(Exchange, ImplicitAPI):
         ohlcvs = []
         for i in range(0, len(openList)):
             if market['quote'] == 'IRT':
-                openList[i] /= 10
-                highList[i] /= 10
-                lowList[i] /= 10
-                closeList[i] /= 10
-                volumeList[i] /= 10
+                openList[i] = openList[i] / 10 if openList[i] else 0
+                highList[i] = highList[i] / 10 if highList[i] else 0
+                lowList[i] = lowList[i] / 10 if lowList[i] else 0
+                closeList[i] = closeList[i] / 10 if closeList[i] else 0
+                volumeList[i] = volumeList[i] / 10 if volumeList[i] else 0
             ohlcvs.append([
                 timestampList[i],
                 openList[i],
@@ -448,7 +448,7 @@ class bitir(Exchange, ImplicitAPI):
     async def fetch_order_book(self, symbol: str, limit: Int = None, params={}) -> OrderBook:
         """
         fetches information on open orders with bid(buy) and ask(sell) prices, volumes and other data for multiple markets
-        :see: https://www.bit.ir/fa
+        https://www.bit.ir/fa
         :param str[]|None symbols: list of unified market symbols, all symbols fetched if None, default is None
         :param int [limit]: max number of entries per orderbook to return, default is None
         :param dict [params]: extra parameters specific to the exchange API endpoint
@@ -464,15 +464,15 @@ class bitir(Exchange, ImplicitAPI):
         orberbook = {'asks': [], 'bids': []}
         for i in range(0, len(orderbookList)):
             orderType = self.safe_string(orderbookList[i], 'type')
-            price = self.safe_float(orderbookList[i], 'price')
-            amount = self.safe_float(orderbookList[i], 'amount')
+            price = self.safe_float(orderbookList[i], 'price', 0)
+            amount = self.safe_float(orderbookList[i], 'amount', 0)
             if orderType == 'sell':
                 if market['quote'] == 'IRT':
-                    price /= 10
+                    price = price / 10
                 orberbook['asks'].append([price, amount])
             if orderType == 'buy':
                 if market['quote'] == 'IRT':
-                    price /= 10
+                    price = price / 10
                 orberbook['bids'].append([price, amount])
         timestamp = Date.now()
         return self.parse_order_book(orberbook, symbol, timestamp)