ccxt 4.3.54__py2.py3-none-any.whl → 4.3.55__py2.py3-none-any.whl

ccxt/pro/cex.py

@@ -640,7 +640,7 @@ class cex(ccxt.async_support.cex):
         #             }
         #         }
         #     }
-        #  fullfilledOrder
+        #  fulfilledOrder
         #     {
         #         "e": "order",
         #         "data": {
@@ -1187,7 +1187,7 @@ class cex(ccxt.async_support.cex):
         :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 price: the price at which the order is to be fullfilled, in units of the quote currency, ignored in market orders
+        :param float price: the price at which the order is to be fulfilled, in units of the quote currency, ignored in market orders
         :param dict [params]: extra parameters specific to the kraken api endpoint
         :param boolean [params.maker_only]: Optional, maker only places an order only if offers best sell(<= max) or buy(>= max) price for self pair, if not order placement will be rejected with an error - "Order is not maker"
         :returns dict: an `order structure <https://docs.ccxt.com/en/latest/manual.html#order-structure>`
@@ -1222,7 +1222,7 @@ class cex(ccxt.async_support.cex):
         :param str type: 'market' or 'limit'
         :param str side: 'buy' or 'sell'
         :param float amount: how much of the currency you want to trade in units of the base currency
-        :param float|None [price]: the price at which the order is to be fullfilled, in units of the quote currency, ignored in market orders
+        :param float|None [price]: the price at which the order is to be fulfilled, in units of the quote currency, ignored in market orders
         :param dict [params]: extra parameters specific to the cex api endpoint
         :returns dict: an `order structure <https://docs.ccxt.com/en/latest/manual.html#order-structure>`
         """

ccxt/pro/coinbase.py

@@ -660,6 +660,25 @@ class coinbase(ccxt.async_support.coinbase):
         #
         return message
 
+    def handle_heartbeats(self, client, message):
+        # although the subscription takes a product_ids parameter(i.e. symbol),
+        # there is no(clear) way of mapping the message back to the symbol.
+        #
+        #     {
+        #         "channel": "heartbeats",
+        #         "client_id": "",
+        #         "timestamp": "2023-06-23T20:31:26.122969572Z",
+        #         "sequence_num": 0,
+        #         "events": [
+        #           {
+        #               "current_time": "2023-06-23 20:31:56.121961769 +0000 UTC m=+91717.525857105",
+        #               "heartbeat_counter": "3049"
+        #           }
+        #         ]
+        #     }
+        #
+        return message
+
     def handle_message(self, client, message):
         channel = self.safe_string(message, 'channel')
         methods: dict = {
@@ -669,10 +688,12 @@ class coinbase(ccxt.async_support.coinbase):
             'market_trades': self.handle_trade,
             'user': self.handle_order,
             'l2_data': self.handle_order_book,
+            'heartbeats': self.handle_heartbeats,
         }
         type = self.safe_string(message, 'type')
         if type == 'error':
             errorMessage = self.safe_string(message, 'message')
             raise ExchangeError(errorMessage)
         method = self.safe_value(methods, channel)
-        method(client, message)
+        if method:
+            method(client, message)

ccxt/pro/cryptocom.py

@@ -682,7 +682,7 @@ class cryptocom(ccxt.async_support.cryptocom):
         :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 [price]: the price at which the order is to be fullfilled, in units of the quote currency, ignored in market orders
+        :param float [price]: the price at which the order is to be fulfilled, in units of the quote currency, ignored in market orders
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """

ccxt/pro/gate.py

@@ -138,7 +138,7 @@ class gate(ccxt.async_support.gate):
         :param str type: 'limit' or 'market' *"market" is contract only*
         :param str side: 'buy' or 'sell'
         :param float amount: the amount of currency to trade
-        :param float [price]: *ignored in "market" orders* the price at which the order is to be fullfilled at in units of the quote currency
+        :param float [price]: *ignored in "market" orders* the price at which the order is to be fulfilled at in units of the quote currency
         :param dict [params]:  extra parameters specific to the exchange API endpoint
         :param float [params.stopPrice]: The price at which a trigger order is triggered at
         :param str [params.timeInForce]: "GTC", "IOC", or "PO"
@@ -249,7 +249,7 @@ class gate(ccxt.async_support.gate):
         :param str type: 'market' or 'limit'
         :param str side: 'buy' or 'sell'
         :param float amount: how much of the currency 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 base currency, ignored in market orders
+        :param float [price]: the price at which the order is to be fulfilled, in units of the quote currency, ignored in market orders
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """

ccxt/pro/hitbtc.py

@@ -954,7 +954,7 @@ class hitbtc(ccxt.async_support.hitbtc):
         :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 [price]: the price at which the order is to be fullfilled, in units of the quote currency, ignored in market orders
+        :param float [price]: the price at which the order is to be fulfilled, in units of the quote currency, ignored in market orders
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :param str [params.marginMode]: 'cross' or 'isolated' only 'isolated' is supported for spot-margin, swap supports both, default is 'cross'
         :param bool [params.margin]: True for creating a margin order

ccxt/pro/kraken.py

@@ -131,7 +131,7 @@ class kraken(ccxt.async_support.kraken):
         :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 [price]: the price at which the order is to be fullfilled, in units of the quote currency, ignored in market orders
+        :param float [price]: the price at which the order is to be fulfilled, in units of the quote currency, ignored in market orders
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """
@@ -186,7 +186,7 @@ class kraken(ccxt.async_support.kraken):
         :param str type: 'market' or 'limit'
         :param str side: 'buy' or 'sell'
         :param float amount: how much of the currency 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 float [price]: the price at which the order is to be fulfilled, in units of the quote currency, ignored in market orders
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """

ccxt/pro/kucoin.py

@@ -999,8 +999,8 @@ class kucoin(ccxt.async_support.kucoin):
         type = self.safe_string(trade, 'orderType')
         side = self.safe_string(trade, 'side')
         tradeId = self.safe_string(trade, 'tradeId')
-        price = self.safe_string(trade, 'price')
-        amount = self.safe_string(trade, 'size')
+        price = self.safe_string(trade, 'matchPrice')
+        amount = self.safe_string(trade, 'matchSize')
         order = self.safe_string(trade, 'orderId')
         timestamp = self.safe_integer_product(trade, 'ts', 0.000001)
         return self.safe_trade({

ccxt/pro/okx.py

@@ -1520,7 +1520,7 @@ class okx(ccxt.async_support.okx):
         :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|None [price]: the price at which the order is to be fullfilled, in units of the quote currency, ignored in market orders
+        :param float|None [price]: the price at which the order is to be fulfilled, in units of the quote currency, ignored in market orders
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :param boolean params['test']: test order, default False
         :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
@@ -1586,7 +1586,7 @@ class okx(ccxt.async_support.okx):
         :param str type: 'market' or 'limit'
         :param str side: 'buy' or 'sell'
         :param float amount: how much of the currency you want to trade in units of the base currency
-        :param float|None [price]: the price at which the order is to be fullfilled, in units of the quote currency, ignored in market orders
+        :param float|None [price]: the price at which the order is to be fulfilled, in units of the quote currency, ignored in market orders
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """

ccxt/pro/oxfun.py

@@ -715,7 +715,7 @@ class oxfun(ccxt.async_support.oxfun):
         :param str type: 'market', 'limit', 'STOP_LIMIT' or 'STOP_MARKET'
         :param str side: 'buy' or 'sell'
         :param float amount: how much of currency you want to trade in units of 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 float [price]: the price at which the order is to be fulfilled, in units of the quote currency, ignored in market orders
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :param int [params.clientOrderId]: a unique id for the order
         :param int [params.timestamp]: in milliseconds. If an order reaches the matching engine and the current timestamp exceeds timestamp + recvWindow, then the order will be rejected.
@@ -754,7 +754,7 @@ class oxfun(ccxt.async_support.oxfun):
         :param str type: 'market' or 'limit'
         :param str side: 'buy' or 'sell'
         :param float amount: how much of the currency you want to trade in units of the base currency
-        :param float|None [price]: the price at which the order is to be fullfilled, in units of the quote currency, ignored in market orders
+        :param float|None [price]: the price at which the order is to be fulfilled, in units of the quote currency, ignored in market orders
         :param int [params.timestamp]: in milliseconds. If an order reaches the matching engine and the current timestamp exceeds timestamp + recvWindow, then the order will be rejected.
         :param int [params.recvWindow]: in milliseconds. If an order reaches the matching engine and the current timestamp exceeds timestamp + recvWindow, then the order will be rejected. If timestamp is provided without recvWindow, then a default recvWindow of 1000ms is used.
         :param dict [params]: extra parameters specific to the exchange API endpoint

ccxt/pro/poloniex.py

@@ -190,7 +190,7 @@ class poloniex(ccxt.async_support.poloniex):
         :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 [price]: the price at which the order is to be fullfilled, in units of the quote currency, ignored in market orders
+        :param float [price]: the price at which the order is to be fulfilled, in units of the quote currency, ignored in market orders
         :param dict [params]: extra parameters specific to the poloniex api endpoint
         :param str [params.timeInForce]: GTC(default), IOC, FOK
         :param str [params.clientOrderId]: Maximum 64-character length.*

ccxt/pro/vertex.py

@@ -256,7 +256,7 @@ class vertex(ccxt.async_support.vertex):
         price = self.convertFromX18(self.safe_string(trade, 'price'))
         amount = self.convertFromX18(self.safe_string_2(trade, 'taker_qty', 'filled_qty'))
         cost = Precise.string_mul(price, amount)
-        timestamp = Precise.string_div(self.safe_string(trade, 'timestamp'), '1000000')
+        timestamp = self.safe_integer_product(trade, 'timestamp', 0.000001)
         takerOrMaker = None
         isTaker = self.safe_bool(trade, 'is_taker')
         if isTaker is not None:

ccxt/probit.py

@@ -1132,7 +1132,7 @@ class probit(Exchange, ImplicitAPI):
         :param str type: 'market' or 'limit'
         :param str side: 'buy' or 'sell'
         :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 float [price]: the price at which the order is to be fulfilled, 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>`

ccxt/test/{test_async.py → tests_async.py}

@@ -1,269 +1,10 @@
 # -*- coding: utf-8 -*-
 
-import argparse
-import json
-# import logging
-import os
-import sys
-from traceback import format_tb, format_exception
-
-import importlib  # noqa: E402
-import re
-
-# ------------------------------------------------------------------------------
-# logging.basicConfig(level=logging.INFO)
-# ------------------------------------------------------------------------------
-DIR_NAME = os.path.dirname(os.path.abspath(__file__))
-root = os.path.dirname(os.path.dirname(DIR_NAME))
-sys.path.append(root)
-
-import ccxt.async_support as ccxt  # noqa: E402
-import ccxt.pro as ccxtpro  # noqa: E402
-
-# ------------------------------------------------------------------------------
 import asyncio
-# from typing import Optional
-# from typing import List
-from ccxt.base.errors import NotSupported
-from ccxt.base.errors import ProxyError
-from ccxt.base.errors import OperationFailed
-# from ccxt.base.errors import ExchangeError
-from ccxt.base.errors import ExchangeNotAvailable
-from ccxt.base.errors import OnMaintenance
-from ccxt.base.errors import AuthenticationError
-
-# ------------------------------------------------------------------------------
-
-class Argv(object):
-    id_tests = False
-    static_tests = False
-    ws_tests = False
-    request_tests = False
-    response_tests = False
-    token_bucket = False
-    sandbox = False
-    privateOnly = False
-    private = False
-    ws = False
-    verbose = False
-    nonce = None
-    exchange = None
-    symbol = None
-    info = False
-    pass
-
-
-argv = Argv()
-parser = argparse.ArgumentParser()
-parser.add_argument('--token_bucket', action='store_true', help='enable token bucket experimental test')
-parser.add_argument('--sandbox', action='store_true', help='enable sandbox mode')
-parser.add_argument('--privateOnly', action='store_true', help='run private tests only')
-parser.add_argument('--private', action='store_true', help='run private tests')
-parser.add_argument('--verbose', action='store_true', help='enable verbose output')
-parser.add_argument('--ws', action='store_true', help='websockets version')
-parser.add_argument('--info', action='store_true', help='enable info output')
-parser.add_argument('--static', action='store_true', help='run static tests')
-parser.add_argument('--useProxy', action='store_true', help='run static tests')
-parser.add_argument('--idTests', action='store_true', help='run brokerId tests')
-parser.add_argument('--responseTests', action='store_true', help='run response tests')
-parser.add_argument('--requestTests', action='store_true', help='run response tests')
-parser.add_argument('--nonce', type=int, help='integer')
-parser.add_argument('exchange', type=str, help='exchange id in lowercase', nargs='?')
-parser.add_argument('symbol', type=str, help='symbol in uppercase', nargs='?')
-parser.parse_args(namespace=argv)
-
-# ------------------------------------------------------------------------------
-
-path = os.path.dirname(ccxt.__file__)
-if 'site-packages' in os.path.dirname(ccxt.__file__):
-    raise Exception("You are running test_async.py/test.py against a globally-installed version of the library! It was previously installed into your site-packages folder by pip or pip3. To ensure testing against the local folder uninstall it first with pip uninstall ccxt or pip3 uninstall ccxt")
-
-# ------------------------------------------------------------------------------
-
-Error = Exception
-
-# # print an error string
-# def dump_error(*args):
-#     string = ' '.join([str(arg) for arg in args])
-#     print(string)
-#     sys.stderr.write(string + "\n")
-#     sys.stderr.flush()
-
-
-def handle_all_unhandled_exceptions(type, value, traceback):
-    dump((type), (value), '\n<UNHANDLED EXCEPTION>\n' + ('\n'.join(format_tb(traceback))))
-    exit(1)  # unrecoverable crash
-
-
-sys.excepthook = handle_all_unhandled_exceptions
-# ------------------------------------------------------------------------------
-
-# non-transpiled part, but shared names among langs
-
-is_synchronous = 'async' not in os.path.basename(__file__)
-
-rootDir = DIR_NAME + '/../../../'
-rootDirForSkips = DIR_NAME + '/../../../'
-envVars = os.environ
-LOG_CHARS_LENGTH = 10000
-ext = 'py'
-proxyTestFileName = 'proxies'
-
-
-def get_cli_arg_value(arg):
-    arg_exists = getattr(argv, arg) if hasattr(argv, arg) else False
-    with_hyphen = '--' + arg
-    arg_exists_with_hyphen = getattr(argv, with_hyphen) if hasattr(argv, with_hyphen) else False
-    without_hyphen = arg.replace('--', '')
-    arg_exists_wo_hyphen = getattr(argv, without_hyphen) if hasattr(argv, without_hyphen) else False
-    return arg_exists or arg_exists_with_hyphen or arg_exists_wo_hyphen
-
-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]))
+from tests_helpers import get_cli_arg_value, dump, exit_script, get_test_files, init_exchange, set_exchange_prop, call_method, exception_message, io_file_exists, io_file_read, baseMainTestClass, AuthenticationError, NotSupported, OperationFailed, OnMaintenance, ExchangeNotAvailable, ProxyError, get_exchange_prop, close, json_parse, json_stringify, is_null_value, io_dir_read, convert_ascii, call_exchange_method_dynamically, set_fetch_response, call_exchange_method_dynamically_sync  # noqa: F401
 
-
-def convert_ascii(str):
-    return str  # stub
-
-def json_parse(elem):
-    return json.loads(elem)
-
-
-def json_stringify(elem):
-    return json.dumps(elem)
-
-
-def convert_to_snake_case(content):
-    res = re.sub(r'(?<!^)(?=[A-Z])', '_', content).lower()
-    return res.replace('o_h_l_c_v', 'ohlcv')
-
-
-def get_test_name(methodName):
-    # stub
-    return methodName
-
-
-def io_file_exists(path):
-    return os.path.isfile(path)
-
-
-def io_file_read(path, decode=True):
-    fs = open(path, "r", encoding="utf-8")
-    content = fs.read()
-    if decode:
-        return json.loads(content)
-    else:
-        return content
-
-
-def io_dir_read(path):
-    return os.listdir(path)
-
-
-async def call_method(test_files, methodName, exchange, skippedProperties, args):
-    methodNameToCall = 'test_' + convert_to_snake_case(methodName)
-    return await getattr(test_files[methodName], methodNameToCall)(exchange, skippedProperties, *args)
-
-
-async def call_exchange_method_dynamically(exchange, methodName, args):
-    return await getattr(exchange, methodName)(*args)
-
-async def call_overriden_method(exchange, methodName, args):
-    # needed for php
-    return await call_exchange_method_dynamically(exchange, methodName, args)
-
-def exception_message(exc):
-    message = '[' + type(exc).__name__ + '] ' + "".join(format_exception(type(exc), exc, exc.__traceback__, limit=6))
-    if len(message) > LOG_CHARS_LENGTH:
-        # Accessing out of range element causes error
-        message = message[0:LOG_CHARS_LENGTH]
-    return message
-
-
-def exit_script(code=0):
-    exit(code)
-
-
-def get_exchange_prop(exchange, prop, defaultValue=None):
-    if hasattr(exchange, prop):
-        res = getattr(exchange, prop)
-        if res is not None and res != '':
-            return res
-    return defaultValue
-
-
-def set_exchange_prop(exchange, prop, value):
-    setattr(exchange, prop, value)
-    # set snake case too
-    setattr(exchange, convert_to_snake_case(prop), value)
-
-
-def init_exchange(exchangeId, args, is_ws=False):
-    if (is_ws):
-        return getattr(ccxtpro, exchangeId)(args)
-    return getattr(ccxt, exchangeId)(args)
-
-
-async def get_test_files(properties, ws=False):
-    tests = {}
-    finalPropList = properties + [proxyTestFileName]
-    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'
-        dir_to_test = DIR_NAME + '/' + prefix + '/'
-        module_string = 'ccxt.test.' + prefix + '.test_' + name_snake_case
-        if (ws):
-            prefix = 'pro'
-            dir_to_test = DIR_NAME + '/../' + prefix + '/test/Exchange/'
-            module_string = 'ccxt.pro.test.Exchange.test_' + name_snake_case
-        filePathWithExt = dir_to_test + 'test_' + name_snake_case + '.py'
-        if (io_file_exists (filePathWithExt)):
-            imp = importlib.import_module(module_string)
-            tests[methodName] = imp  # getattr(imp, finalName)
-    return tests
-
-async def close(exchange):
-    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):
-    async def fetch(url, method='GET', headers=None, body=None):
-        return data
-    exchange.fetch = fetch
-    return exchange
-
-# *********************************
-# ***** AUTO-TRANSPILER-START *****
 class testMainClass(baseMainTestClass):
     def parse_cli_args(self):
         self.response_tests = get_cli_arg_value('--responseTests')
@@ -452,7 +193,9 @@ class testMainClass(baseMainTestClass):
             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), self.exchange_hint(exchange), method_name, args_stringified)
         await call_method(self.test_files, method_name, exchange, skipped_properties_for_method, args)
-        # if it was passed successfully, add to the list of successfull tests
+        if self.info:
+            dump(self.add_padding('[INFO] TESTING DONE', 25), self.exchange_hint(exchange), method_name)
+        # add to the list of successed tests
         if is_public:
             self.checked_public_tests[method_name] = True
         return
@@ -507,7 +250,7 @@ class testMainClass(baseMainTestClass):
         # formatted message "[TEST_FAILURE] ..." and that output is then regex-matched by
         # run-tests.js, so the exceptions are still printed out to console from there.
         max_retries = 3
-        args_stringified = exchange.json(args)  # args.join() breaks when we provide a list of symbols | "args.toString()" breaks bcz of "array to string conversion"
+        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"
         for i in range(0, max_retries):
             try:
                 await self.test_method(method_name, exchange, args, is_public)
@@ -836,12 +579,16 @@ class testMainClass(baseMainTestClass):
         for j in range(0, max_retries):
             try:
                 await self.test_method(proxy_test_name, exchange, [], True)
-                break  # if successfull, then break
+                return   # if successfull, then end the test
             except Exception as e:
                 exception = e
+                await exchange.sleep(j * 1000)
         # if exception was set, then throw it
-        if exception:
+        if exception is not None:
             error_message = '[TEST_FAILURE] Failed ' + proxy_test_name + ' : ' + exception_message(exception)
+            # temporary comment the below, because c# transpilation failure
+            # throw new ExchangeError (errorMessage.toString ());
+            dump('[TEST_WARNING]' + str(error_message))
 
     async def start_test(self, exchange, symbol):
         # we do not need to test aliases
@@ -1075,7 +822,10 @@ class testMainClass(baseMainTestClass):
         output = None
         request_url = None
         try:
-            await call_exchange_method_dynamically(exchange, method, self.sanitize_data_input(data['input']))
+            if not self.is_synchronous:
+                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']))
         except Exception as e:
             if not (isinstance(e, ProxyError)):
                 raise e
@@ -1093,8 +843,12 @@ class testMainClass(baseMainTestClass):
         expected_result = exchange.safe_value(data, 'parsedResponse')
         mocked_exchange = set_fetch_response(exchange, data['httpResponse'])
         try:
-            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)
+            if not self.is_synchronous:
+                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:
+                unified_result_sync = call_exchange_method_dynamically_sync(exchange, method, self.sanitize_data_input(data['input']))
+                self.assert_static_response_output(mocked_exchange, skip_keys, unified_result_sync, expected_result)
         except Exception as e:
             self.request_tests_failed = True
             error_message = '[' + self.lang + '][STATIC_RESPONSE_TEST_FAILURE]' + '[' + self.exchange_hint(exchange) + ']' + '[' + method + ']' + '[' + data['description'] + ']' + str(e)
@@ -1179,7 +933,8 @@ class testMainClass(baseMainTestClass):
                 # reset options
                 # exchange.options = exchange.deepExtend (oldExchangeOptions, {});
                 exchange.extend_exchange_options(exchange.deep_extend(old_exchange_options, {}))
-        await close(exchange)
+        if not self.is_synchronous:
+            await close(exchange)
         return True   # in c# methods that will be used with promiseAll need to return something
 
     async def test_exchange_response_statically(self, exchange_name, exchange_data, test_name=None):
@@ -1228,7 +983,8 @@ class testMainClass(baseMainTestClass):
                 # reset options
                 # exchange.options = exchange.deepExtend (oldExchangeOptions, {});
                 exchange.extend_exchange_options(exchange.deep_extend(old_exchange_options, {}))
-        await close(exchange)
+        if not self.is_synchronous:
+            await close(exchange)
         return True   # in c# methods that will be used with promiseAll need to return something
 
     def get_number_of_tests_from_exchange(self, exchange, exchange_data, test_name=None):
@@ -1273,7 +1029,8 @@ class testMainClass(baseMainTestClass):
         if self.request_tests_failed or self.response_tests_failed:
             exit_script(1)
         else:
-            success_message = '[' + self.lang + '][TEST_SUCCESS] ' + str(sum) + ' static ' + type + ' tests passed.'
+            prefix = '[SYNC]' if (self.is_synchronous) else ''
+            success_message = '[' + self.lang + ']' + prefix + '[TEST_SUCCESS] ' + str(sum) + ' static ' + type + ' tests passed.'
             dump('[INFO]' + success_message)
 
     async def run_static_response_tests(self, exchange_name=None, test=None):
@@ -1671,13 +1428,3 @@ class testMainClass(baseMainTestClass):
         assert broker_id == id, 'vertex - id: ' + str(id) + ' different from  broker_id: ' + str(broker_id)
         await close(exchange)
         return True
-
-# ***** AUTO-TRANSPILER-END *****
-# *******************************
-
-
-if __name__ == '__main__':
-    argvSymbol = argv.symbol if argv.symbol and '/' in argv.symbol else None
-    # in python, we check it through "symbol" arg (as opposed to JS/PHP) because argvs were already built above
-    argvMethod = argv.symbol if argv.symbol and '()' in argv.symbol else None
-    asyncio.run(testMainClass().init(argv.exchange, argvSymbol, argvMethod))