ccxt 4.4.12__py2.py3-none-any.whl → 4.4.14__py2.py3-none-any.whl

ccxt/pro/woo.py

@@ -27,6 +27,7 @@ class woo(ccxt.async_support.woo):
                 'watchOrders': True,
                 'watchTicker': True,
                 'watchTickers': True,
+                'watchBidsAsks': True,
                 'watchTrades': True,
                 'watchTradesForSymbols': False,
                 'watchPositions': True,
@@ -383,6 +384,73 @@ class woo(ccxt.async_support.woo):
             result.append(ticker)
         client.resolve(result, topic)
 
+    async def watch_bids_asks(self, symbols: Strings = None, params={}) -> Tickers:
+        """
+        :see: https://docs.woox.io/#bbos
+        watches best bid & ask for symbols
+        :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>`
+        """
+        await self.load_markets()
+        symbols = self.market_symbols(symbols, None, False)
+        name = 'bbos'
+        topic = name
+        request: dict = {
+            'event': 'subscribe',
+            'topic': topic,
+        }
+        message = self.extend(request, params)
+        tickers = await self.watch_public(topic, message)
+        if self.newUpdates:
+            return tickers
+        return self.filter_by_array(self.bidsasks, 'symbol', symbols)
+
+    def handle_bid_ask(self, client: Client, message):
+        #
+        #     {
+        #         "topic": "bbos",
+        #         "ts": 1618822376000,
+        #         "data": [
+        #             {
+        #                 "symbol": "SPOT_FIL_USDT",
+        #                 "ask": 159.0318,
+        #                 "askSize": 370.43,
+        #                 "bid": 158.9158,
+        #                 "bidSize": 16
+        #             }
+        #         ]
+        #     }
+        #
+        topic = self.safe_string(message, 'topic')
+        data = self.safe_list(message, 'data', [])
+        timestamp = self.safe_integer(message, 'ts')
+        result: dict = {}
+        for i in range(0, len(data)):
+            ticker = self.safe_dict(data, i)
+            ticker['ts'] = timestamp
+            parsedTicker = self.parse_ws_bid_ask(ticker)
+            symbol = parsedTicker['symbol']
+            self.bidsasks[symbol] = parsedTicker
+            result[symbol] = parsedTicker
+        client.resolve(result, topic)
+
+    def parse_ws_bid_ask(self, ticker, market=None):
+        marketId = self.safe_string(ticker, 'symbol')
+        market = self.safe_market(marketId, market)
+        symbol = self.safe_string(market, 'symbol')
+        timestamp = self.safe_integer(ticker, 'ts')
+        return self.safe_ticker({
+            'symbol': symbol,
+            'timestamp': timestamp,
+            'datetime': self.iso8601(timestamp),
+            'ask': self.safe_string(ticker, 'ask'),
+            'askVolume': self.safe_string(ticker, 'askSize'),
+            'bid': self.safe_string(ticker, 'bid'),
+            'bidVolume': self.safe_string(ticker, 'bidSize'),
+            'info': ticker,
+        }, market)
+
     async def watch_ohlcv(self, symbol: str, timeframe='1m', since: Int = None, limit: Int = None, params={}) -> List[list]:
         """
         watches historical candlestick data containing the open, high, low, and close price, and the volume of a market
@@ -1101,6 +1169,7 @@ class woo(ccxt.async_support.woo):
             'trade': self.handle_trade,
             'balance': self.handle_balance,
             'position': self.handle_positions,
+            'bbos': self.handle_bid_ask,
         }
         event = self.safe_string(message, 'event')
         method = self.safe_value(methods, event)

ccxt/test/tests_async.py

@@ -3,10 +3,34 @@
 import asyncio
 
 
-from tests_helpers import AuthenticationError, NotSupported, InvalidProxySettings, ExchangeNotAvailable, OperationFailed, OnMaintenance, get_cli_arg_value, baseMainTestClass, dump, json_parse, json_stringify, convert_ascii, io_file_exists, io_file_read, io_dir_read, call_method, call_method_sync, call_exchange_method_dynamically, call_exchange_method_dynamically_sync, get_root_exception, exception_message, exit_script, get_exchange_prop, set_exchange_prop, init_exchange, get_test_files_sync, get_test_files, set_fetch_response, is_null_value, close  # noqa: F401
-
-class testMainClass(baseMainTestClass):
-    def parse_cli_args(self):
+from tests_helpers import AuthenticationError, NotSupported, InvalidProxySettings, ExchangeNotAvailable, OperationFailed, OnMaintenance, get_cli_arg_value, get_root_dir, is_sync, dump, json_parse, json_stringify, convert_ascii, io_file_exists, io_file_read, io_dir_read, call_method, call_method_sync, call_exchange_method_dynamically, call_exchange_method_dynamically_sync, get_root_exception, exception_message, exit_script, get_exchange_prop, set_exchange_prop, init_exchange, get_test_files_sync, get_test_files, set_fetch_response, is_null_value, close, get_env_vars, get_lang, get_ext  # noqa: F401
+
+class testMainClass:
+    id_tests = False
+    request_tests_failed = False
+    response_tests_failed = False
+    request_tests = False
+    ws_tests = False
+    response_tests = False
+    static_tests = False
+    info = False
+    verbose = False
+    debug = False
+    private_test = False
+    private_test_only = False
+    load_keys = False
+    sandbox = False
+    only_specific_tests = []
+    skipped_settings_for_exchange = {}
+    skipped_methods = {}
+    checked_public_tests = {}
+    test_files = {}
+    public_tests = {}
+    ext = ''
+    lang = ''
+    proxy_test_file_name = 'proxies'
+
+    def parse_cli_args_and_props(self):
         self.response_tests = get_cli_arg_value('--responseTests')
         self.id_tests = get_cli_arg_value('--idTests')
         self.request_tests = get_cli_arg_value('--requestTests')
@@ -18,9 +42,11 @@ class testMainClass(baseMainTestClass):
         self.sandbox = get_cli_arg_value('--sandbox')
         self.load_keys = get_cli_arg_value('--loadKeys')
         self.ws_tests = get_cli_arg_value('--ws')
+        self.lang = get_lang()
+        self.ext = get_ext()
 
     async def init(self, exchange_id, symbol_argv, method_argv):
-        self.parse_cli_args()
+        self.parse_cli_args_and_props()
         if self.request_tests and self.response_tests:
             await self.run_static_request_tests(exchange_id, symbol_argv)
             await self.run_static_response_tests(exchange_id, symbol_argv)
@@ -34,12 +60,13 @@ class testMainClass(baseMainTestClass):
         if self.id_tests:
             await self.run_broker_id_tests()
             return
-        dump(self.new_line + '' + self.new_line + '' + '[INFO] TESTING ', self.ext, {
+        new_line = '\n'
+        dump(new_line + '' + new_line + '' + '[INFO] TESTING ', self.ext, {
             'exchange': exchange_id,
             'symbol': symbol_argv,
             'method': method_argv,
             'isWs': self.ws_tests,
-        }, self.new_line)
+        }, new_line)
         exchange_args = {
             'verbose': self.verbose,
             'debug': self.debug,
@@ -72,7 +99,7 @@ class testMainClass(baseMainTestClass):
     async def import_files(self, exchange):
         properties = list(exchange.has.keys())
         properties.append('loadMarkets')
-        if self.is_synchronous:
+        if is_sync():
             self.test_files = get_test_files_sync(properties, self.ws_tests)
         else:
             self.test_files = await get_test_files(properties, self.ws_tests)
@@ -87,14 +114,15 @@ class testMainClass(baseMainTestClass):
             if is_required and get_exchange_prop(exchange, credential) is None:
                 full_key = exchange_id + '_' + credential
                 credential_env_name = full_key.upper()  # example: KRAKEN_APIKEY
-                credential_value = self.env_vars[credential_env_name] if (credential_env_name in self.env_vars) else None
+                env_vars = get_env_vars()
+                credential_value = env_vars[credential_env_name] if (credential_env_name in env_vars) else None
                 if credential_value:
                     set_exchange_prop(exchange, credential, credential_value)
 
     def expand_settings(self, exchange):
         exchange_id = exchange.id
-        keys_global = self.root_dir + 'keys.json'
-        keys_local = self.root_dir + 'keys.local.json'
+        keys_global = get_root_dir() + 'keys.json'
+        keys_local = get_root_dir() + 'keys.local.json'
         keys_global_exists = io_file_exists(keys_global)
         keys_local_exists = io_file_exists(keys_local)
         global_settings = io_file_read(keys_global) if keys_global_exists else {}
@@ -117,7 +145,7 @@ class testMainClass(baseMainTestClass):
         if self.load_keys:
             self.load_credentials_from_env(exchange)
         # skipped tests
-        skipped_file = self.root_dir_for_skips + 'skip-tests.json'
+        skipped_file = get_root_dir() + 'skip-tests.json'
         skipped_settings = io_file_read(skipped_file)
         self.skipped_settings_for_exchange = exchange.safe_value(skipped_settings, exchange_id, {})
         skipped_settings_for_exchange = self.skipped_settings_for_exchange
@@ -178,7 +206,7 @@ class testMainClass(baseMainTestClass):
         if self.info:
             args_stringified = '(' + exchange.json(args) + ')'  # args.join() breaks when we provide a list of symbols or multidimensional array; "args.toString()" breaks bcz of "array to string conversion"
             dump(self.add_padding('[INFO] TESTING', 25), name, method_name, args_stringified)
-        if self.is_synchronous:
+        if is_sync():
             call_method_sync(self.test_files, method_name, exchange, skipped_properties_for_method, args)
         else:
             await call_method(self.test_files, method_name, exchange, skipped_properties_for_method, args)
@@ -561,7 +589,7 @@ class testMainClass(baseMainTestClass):
         # these tests should be synchronously executed, because of conflicting nature of proxy settings
         proxy_test_name = self.proxy_test_file_name
         # todo: temporary skip for sync py
-        if self.ext == 'py' and self.is_synchronous:
+        if self.ext == 'py' and is_sync():
             return
         # try proxy several times
         max_retries = 3
@@ -589,7 +617,7 @@ class testMainClass(baseMainTestClass):
         try:
             result = await self.load_exchange(exchange)
             if not result:
-                if not self.is_synchronous:
+                if not is_sync():
                     await close(exchange)
                 return
             # if (exchange.id === 'binance') {
@@ -597,10 +625,10 @@ class testMainClass(baseMainTestClass):
             #     # await this.testProxies (exchange);
             # }
             await self.test_exchange(exchange, symbol)
-            if not self.is_synchronous:
+            if not is_sync():
                 await close(exchange)
         except Exception as e:
-            if not self.is_synchronous:
+            if not is_sync():
                 await close(exchange)
             raise e
 
@@ -620,12 +648,12 @@ class testMainClass(baseMainTestClass):
         # to make this test as fast as possible
         # and basically independent from the exchange
         # so we can run it offline
-        filename = self.root_dir + './ts/src/test/static/markets/' + id + '.json'
+        filename = get_root_dir() + './ts/src/test/static/markets/' + id + '.json'
         content = io_file_read(filename)
         return content
 
     def load_currencies_from_file(self, id):
-        filename = self.root_dir + './ts/src/test/static/currencies/' + id + '.json'
+        filename = get_root_dir() + './ts/src/test/static/currencies/' + id + '.json'
         content = io_file_read(filename)
         return content
 
@@ -815,7 +843,7 @@ class testMainClass(baseMainTestClass):
         output = None
         request_url = None
         try:
-            if not self.is_synchronous:
+            if not is_sync():
                 await call_exchange_method_dynamically(exchange, method, self.sanitize_data_input(data['input']))
             else:
                 call_exchange_method_dynamically_sync(exchange, method, self.sanitize_data_input(data['input']))
@@ -836,7 +864,7 @@ class testMainClass(baseMainTestClass):
         expected_result = exchange.safe_value(data, 'parsedResponse')
         mocked_exchange = set_fetch_response(exchange, data['httpResponse'])
         try:
-            if not self.is_synchronous:
+            if not is_sync():
                 unified_result = await call_exchange_method_dynamically(exchange, method, self.sanitize_data_input(data['input']))
                 self.assert_static_response_output(mocked_exchange, skip_keys, unified_result, expected_result)
             else:
@@ -932,7 +960,7 @@ class testMainClass(baseMainTestClass):
                 # reset options
                 # exchange.options = exchange.deepExtend (oldExchangeOptions, {});
                 exchange.extend_exchange_options(exchange.deep_extend(old_exchange_options, {}))
-        if not self.is_synchronous:
+        if not is_sync():
             await close(exchange)
         return True   # in c# methods that will be used with promiseAll need to return something
 
@@ -982,7 +1010,7 @@ class testMainClass(baseMainTestClass):
                 # reset options
                 # exchange.options = exchange.deepExtend (oldExchangeOptions, {});
                 exchange.extend_exchange_options(exchange.deep_extend(old_exchange_options, {}))
-        if not self.is_synchronous:
+        if not is_sync():
             await close(exchange)
         return True   # in c# methods that will be used with promiseAll need to return something
 
@@ -1003,7 +1031,7 @@ class testMainClass(baseMainTestClass):
         await self.run_static_tests('request', target_exchange, test_name)
 
     async def run_static_tests(self, type, target_exchange=None, test_name=None):
-        folder = self.root_dir + './ts/src/test/static/' + type + '/'
+        folder = get_root_dir() + './ts/src/test/static/' + type + '/'
         static_data = self.load_static_data(folder, target_exchange)
         if static_data is None:
             return
@@ -1028,7 +1056,7 @@ class testMainClass(baseMainTestClass):
         if self.request_tests_failed or self.response_tests_failed:
             exit_script(1)
         else:
-            prefix = '[SYNC]' if (self.is_synchronous) else ''
+            prefix = '[SYNC]' if (is_sync()) else ''
             success_message = '[' + self.lang + ']' + prefix + '[TEST_SUCCESS] ' + str(sum) + ' static ' + type + ' tests passed.'
             dump('[INFO]' + success_message)
 
@@ -1075,7 +1103,7 @@ class testMainClass(baseMainTestClass):
         assert client_order_id_swap.startswith(swap_id_string), 'binance - swap clientOrderId: ' + client_order_id_swap + ' does not start with swapId' + swap_id_string
         client_order_id_inverse = swap_inverse_order_request['newClientOrderId']
         assert client_order_id_inverse.startswith(swap_id_string), 'binance - swap clientOrderIdInverse: ' + client_order_id_inverse + ' does not start with swapId' + swap_id_string
-        if not self.is_synchronous:
+        if not is_sync():
             await close(exchange)
         return True
 
@@ -1101,7 +1129,7 @@ class testMainClass(baseMainTestClass):
         assert client_order_id_swap.startswith(id_string), 'okx - swap clientOrderId: ' + client_order_id_swap + ' does not start with id: ' + id_string
         swap_tag = swap_order_request[0]['tag']
         assert swap_tag == id, 'okx - id: ' + id + ' different from swap tag: ' + swap_tag
-        if not self.is_synchronous:
+        if not is_sync():
             await close(exchange)
         return True
 
@@ -1116,7 +1144,7 @@ class testMainClass(baseMainTestClass):
             request = json_parse(exchange.last_request_body)
         broker_id = request['params']['broker_id']
         assert broker_id == id, 'cryptocom - id: ' + id + ' different from  broker_id: ' + broker_id
-        if not self.is_synchronous:
+        if not is_sync():
             await close(exchange)
         return True
 
@@ -1131,7 +1159,7 @@ class testMainClass(baseMainTestClass):
             # we expect an error here, we're only interested in the headers
             req_headers = exchange.last_request_headers
         assert req_headers['Referer'] == id, 'bybit - id: ' + id + ' not in headers.'
-        if not self.is_synchronous:
+        if not is_sync():
             await close(exchange)
         return True
 
@@ -1149,7 +1177,7 @@ class testMainClass(baseMainTestClass):
             req_headers = exchange.last_request_headers
         id = 'ccxt'
         assert req_headers['KC-API-PARTNER'] == id, 'kucoin - id: ' + id + ' not in headers.'
-        if not self.is_synchronous:
+        if not is_sync():
             await close(exchange)
         return True
 
@@ -1166,7 +1194,7 @@ class testMainClass(baseMainTestClass):
         except Exception as e:
             req_headers = exchange.last_request_headers
         assert req_headers['KC-API-PARTNER'] == id, 'kucoinfutures - id: ' + id + ' not in headers.'
-        if not self.is_synchronous:
+        if not is_sync():
             await close(exchange)
         return True
 
@@ -1180,7 +1208,7 @@ class testMainClass(baseMainTestClass):
         except Exception as e:
             req_headers = exchange.last_request_headers
         assert req_headers['X-CHANNEL-API-CODE'] == id, 'bitget - id: ' + id + ' not in headers.'
-        if not self.is_synchronous:
+        if not is_sync():
             await close(exchange)
         return True
 
@@ -1195,7 +1223,7 @@ class testMainClass(baseMainTestClass):
         except Exception as e:
             req_headers = exchange.last_request_headers
         assert req_headers['source'] == id, 'mexc - id: ' + id + ' not in headers.'
-        if not self.is_synchronous:
+        if not is_sync():
             await close(exchange)
         return True
 
@@ -1226,7 +1254,7 @@ class testMainClass(baseMainTestClass):
         assert client_order_id_swap.startswith(id_string), 'htx - swap channel_code ' + client_order_id_swap + ' does not start with id: ' + id_string
         client_order_id_inverse = swap_inverse_order_request['channel_code']
         assert client_order_id_inverse.startswith(id_string), 'htx - swap inverse channel_code ' + client_order_id_inverse + ' does not start with id: ' + id_string
-        if not self.is_synchronous:
+        if not is_sync():
             await close(exchange)
         return True
 
@@ -1252,7 +1280,7 @@ class testMainClass(baseMainTestClass):
             stop_order_request = json_parse(exchange.last_request_body)
         client_order_id_stop = stop_order_request['brokerId']
         assert client_order_id_stop.startswith(id_string), 'woo - brokerId: ' + client_order_id_stop + ' does not start with id: ' + id_string
-        if not self.is_synchronous:
+        if not is_sync():
             await close(exchange)
         return True
 
@@ -1267,7 +1295,7 @@ class testMainClass(baseMainTestClass):
         except Exception as e:
             req_headers = exchange.last_request_headers
         assert req_headers['X-BM-BROKER-ID'] == id, 'bitmart - id: ' + id + ' not in headers'
-        if not self.is_synchronous:
+        if not is_sync():
             await close(exchange)
         return True
 
@@ -1283,7 +1311,7 @@ class testMainClass(baseMainTestClass):
         client_order_id = spot_order_request['client_id']
         id_string = str(id)
         assert client_order_id.startswith(id_string), 'coinex - clientOrderId: ' + client_order_id + ' does not start with id: ' + id_string
-        if not self.is_synchronous:
+        if not is_sync():
             await close(exchange)
         return True
 
@@ -1298,7 +1326,7 @@ class testMainClass(baseMainTestClass):
             # we expect an error here, we're only interested in the headers
             req_headers = exchange.last_request_headers
         assert req_headers['X-SOURCE-KEY'] == id, 'bingx - id: ' + id + ' not in headers.'
-        if not self.is_synchronous:
+        if not is_sync():
             await close(exchange)
 
     async def test_phemex(self):
@@ -1312,7 +1340,7 @@ class testMainClass(baseMainTestClass):
         client_order_id = request['clOrdID']
         id_string = str(id)
         assert client_order_id.startswith(id_string), 'phemex - clOrdID: ' + client_order_id + ' does not start with id: ' + id_string
-        if not self.is_synchronous:
+        if not is_sync():
             await close(exchange)
 
     async def test_blofin(self):
@@ -1326,7 +1354,7 @@ class testMainClass(baseMainTestClass):
         broker_id = request['brokerId']
         id_string = str(id)
         assert broker_id.startswith(id_string), 'blofin - brokerId: ' + broker_id + ' does not start with id: ' + id_string
-        if not self.is_synchronous:
+        if not is_sync():
             await close(exchange)
 
     async def test_hyperliquid(self):
@@ -1339,7 +1367,7 @@ class testMainClass(baseMainTestClass):
             request = json_parse(exchange.last_request_body)
         broker_id = str((request['action']['brokerCode']))
         assert broker_id == id, 'hyperliquid - brokerId: ' + broker_id + ' does not start with id: ' + id
-        if not self.is_synchronous:
+        if not is_sync():
             await close(exchange)
 
     async def test_coinbaseinternational(self):
@@ -1354,7 +1382,7 @@ class testMainClass(baseMainTestClass):
             request = json_parse(exchange.last_request_body)
         client_order_id = request['client_order_id']
         assert client_order_id.startswith(str(id)), 'clientOrderId does not start with id'
-        if not self.is_synchronous:
+        if not is_sync():
             await close(exchange)
         return True
 
@@ -1369,7 +1397,7 @@ class testMainClass(baseMainTestClass):
             request = json_parse(exchange.last_request_body)
         client_order_id = request['client_order_id']
         assert client_order_id.startswith(str(id)), 'clientOrderId does not start with id'
-        if not self.is_synchronous:
+        if not is_sync():
             await close(exchange)
         return True
 
@@ -1385,7 +1413,7 @@ class testMainClass(baseMainTestClass):
             request = json_parse(exchange.last_request_body)
         broker_id = request['order_tag']
         assert broker_id == id, 'woofipro - id: ' + id + ' different from  broker_id: ' + broker_id
-        if not self.is_synchronous:
+        if not is_sync():
             await close(exchange)
         return True
 
@@ -1422,7 +1450,7 @@ class testMainClass(baseMainTestClass):
             swap_order_request = json_parse(exchange.last_request_body)
         swap_media = swap_order_request['clientMedia']
         assert swap_media == id, 'xt - id: ' + id + ' different from swap tag: ' + swap_media
-        if not self.is_synchronous:
+        if not is_sync():
             await close(exchange)
         return True
 
@@ -1445,7 +1473,7 @@ class testMainClass(baseMainTestClass):
         order = request['place_order']
         broker_id = order['id']
         assert broker_id == id, 'vertex - id: ' + str(id) + ' different from  broker_id: ' + str(broker_id)
-        if not self.is_synchronous:
+        if not is_sync():
             await close(exchange)
         return True
 
@@ -1487,7 +1515,7 @@ class testMainClass(baseMainTestClass):
         except Exception as e:
             req_headers = exchange.last_request_headers
         assert req_headers['PARADEX-PARTNER'] == id, 'paradex - id: ' + id + ' not in headers'
-        if not self.is_synchronous:
+        if not is_sync():
             await close(exchange)
         return True
 
@@ -1501,6 +1529,6 @@ class testMainClass(baseMainTestClass):
             # we expect an error here, we're only interested in the headers
             req_headers = exchange.last_request_headers
         assert req_headers['INPUT-SOURCE'] == id, 'hashkey - id: ' + id + ' not in headers.'
-        if not self.is_synchronous:
+        if not is_sync():
             await close(exchange)
         return True

ccxt/test/tests_helpers.py

@@ -105,14 +105,15 @@ sys.excepthook = handle_all_unhandled_exceptions
 
 # non-transpiled part, but shared names among langs
 
-is_synchronous = argv.sync  # 'async' not in os.path.basename(__file__)
-
-rootDir = DIR_NAME + '/../../../'
-rootDirForSkips = DIR_NAME + '/../../../'
-envVars = os.environ
+EXT = 'py'
+LANG = 'PY'
+IS_SYNCHRONOUS = argv.sync  # 'async' not in os.path.basename(__file__)
+PROXY_TEST_FILE_NAME = 'proxies'
+ROOT_DIR = DIR_NAME + '/../../../'
+ENV_VARS = os.environ
+NEW_LINE = '\n'
 LOG_CHARS_LENGTH = 10000
-ext = 'py'
-proxyTestFileName = 'proxies'
+
 
 
 def get_cli_arg_value(arg):
@@ -125,30 +126,6 @@ def get_cli_arg_value(arg):
 
 isWsTests = get_cli_arg_value('--ws')
 
-
-class baseMainTestClass():
-    lang = 'PY'
-    is_synchronous = is_synchronous
-    request_tests_failed = False
-    response_tests_failed = False
-    response_tests = False
-    ws_tests = False
-    load_keys = False
-    skipped_settings_for_exchange = {}
-    skipped_methods = {}
-    check_public_tests = {}
-    test_files = {}
-    public_tests = {}
-    new_line = '\n'
-    root_dir = rootDir
-    env_vars = envVars
-    ext = ext
-    root_dir_for_skips = rootDirForSkips
-    only_specific_tests = []
-    proxy_test_file_name = proxyTestFileName
-    pass
-
-
 def dump(*args):
     print(' '.join([str(arg) for arg in args]))
 
@@ -240,7 +217,7 @@ def set_exchange_prop(exchange, prop, value):
 
 
 def init_exchange(exchangeId, args, is_ws=False):
-    if is_synchronous:
+    if IS_SYNCHRONOUS:
         return getattr(ccxt_sync, exchangeId)(args)
     if (is_ws):
         return getattr(ccxtpro, exchangeId)(args)
@@ -249,11 +226,11 @@ def init_exchange(exchangeId, args, is_ws=False):
 
 def get_test_files_sync(properties, ws=False):
     tests = {}
-    finalPropList = properties + [proxyTestFileName]
+    finalPropList = properties + [PROXY_TEST_FILE_NAME]
     for i in range(0, len(finalPropList)):
         methodName = finalPropList[i]
         name_snake_case = convert_to_snake_case(methodName)
-        prefix = 'async' if not is_synchronous else 'sync'
+        prefix = 'async' if not IS_SYNCHRONOUS else 'sync'
         dir_to_test = DIR_NAME + '/exchange/' + prefix + '/'
         module_string = 'ccxt.test.exchange.' + prefix + '.test_' + name_snake_case
         if (ws):
@@ -270,14 +247,14 @@ async def get_test_files(properties, ws=False):
     return get_test_files_sync(properties, ws)
 
 async def close(exchange):
-    if (not is_synchronous and hasattr(exchange, 'close')):
+    if (not IS_SYNCHRONOUS and hasattr(exchange, 'close')):
         await exchange.close()
 
 def is_null_value(value):
     return value is None
 
 def set_fetch_response(exchange: ccxt.Exchange, data):
-    if (is_synchronous):
+    if (IS_SYNCHRONOUS):
         def fetch(url, method='GET', headers=None, body=None):
             return data
         exchange.fetch = fetch
@@ -287,6 +264,20 @@ def set_fetch_response(exchange: ccxt.Exchange, data):
     exchange.fetch = fetch
     return exchange
 
+def get_lang():
+    return LANG
+
+def get_ext():
+    return EXT
+
+def get_root_dir():
+    return ROOT_DIR
+
+def get_env_vars():
+    return ENV_VARS
+
+def is_sync():
+    return IS_SYNCHRONOUS
 
 argvExchange = argv.exchange
 argvSymbol = argv.symbol if argv.symbol and '/' in argv.symbol else None

ccxt/test/tests_init.py

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 
-from tests_helpers import get_cli_arg_value, is_synchronous, argvExchange, argvSymbol, argvMethod
+from tests_helpers import get_cli_arg_value, IS_SYNCHRONOUS, argvExchange, argvSymbol, argvMethod
 
 try:
     import asyncio
@@ -10,6 +10,10 @@ except ImportError:
 from base.tests_init import base_tests_init  # noqa: F401
 from ccxt.pro.test.base.tests_init import test_base_init_ws  # noqa: F401
 
+# fix : https://github.com/aio-libs/aiodns/issues/86
+import sys
+if sys.platform == 'win32':
+    asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
 
 # ########### args ###########
 isWs = get_cli_arg_value('--ws')
@@ -27,7 +31,7 @@ if (isBaseTests):
         exit(0)
 
 # ###### exchange tests #######
-if (is_synchronous):
+if (IS_SYNCHRONOUS):
     from tests_sync import testMainClass as testMainClassSync
     testMainClassSync().init(argvExchange, argvSymbol, argvMethod)
 else: