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

ccxt/test/{test_sync.py → tests_sync.py}

@@ -1,268 +1,7 @@
 # -*- 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  # noqa: E402
-import ccxt.pro as ccxtpro  # noqa: E402
-
-# ------------------------------------------------------------------------------
-# 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
-
-    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('--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
+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
 
-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]))
-
-
-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)
-
-
-def call_method(test_files, methodName, exchange, skippedProperties, args):
-    methodNameToCall = 'test_' + convert_to_snake_case(methodName)
-    return getattr(test_files[methodName], methodNameToCall)(exchange, skippedProperties, *args)
-
-
-def call_exchange_method_dynamically(exchange, methodName, args):
-    return getattr(exchange, methodName)(*args)
-
-def call_overriden_method(exchange, methodName, args):
-    # needed for php
-    return 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)
-
-
-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
-
-def close(exchange):
-    if (not is_synchronous and hasattr(exchange, 'close')):
-        exchange.close()
-
-def is_null_value(value):
-    return value is None
-
-def set_fetch_response(exchange: ccxt.Exchange, data):
-    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')
@@ -451,7 +190,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)
         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
@@ -506,7 +247,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:
                 self.test_method(method_name, exchange, args, is_public)
@@ -835,12 +576,16 @@ class testMainClass(baseMainTestClass):
         for j in range(0, max_retries):
             try:
                 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
+                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))
 
     def start_test(self, exchange, symbol):
         # we do not need to test aliases
@@ -1074,7 +819,10 @@ class testMainClass(baseMainTestClass):
         output = None
         request_url = None
         try:
-            call_exchange_method_dynamically(exchange, method, self.sanitize_data_input(data['input']))
+            if not self.is_synchronous:
+                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
@@ -1092,8 +840,12 @@ class testMainClass(baseMainTestClass):
         expected_result = exchange.safe_value(data, 'parsedResponse')
         mocked_exchange = set_fetch_response(exchange, data['httpResponse'])
         try:
-            unified_result = 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 = 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)
@@ -1178,7 +930,8 @@ class testMainClass(baseMainTestClass):
                 # reset options
                 # exchange.options = exchange.deepExtend (oldExchangeOptions, {});
                 exchange.extend_exchange_options(exchange.deep_extend(old_exchange_options, {}))
-        close(exchange)
+        if not self.is_synchronous:
+            close(exchange)
         return True   # in c# methods that will be used with promiseAll need to return something
 
     def test_exchange_response_statically(self, exchange_name, exchange_data, test_name=None):
@@ -1227,7 +980,8 @@ class testMainClass(baseMainTestClass):
                 # reset options
                 # exchange.options = exchange.deepExtend (oldExchangeOptions, {});
                 exchange.extend_exchange_options(exchange.deep_extend(old_exchange_options, {}))
-        close(exchange)
+        if not self.is_synchronous:
+            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):
@@ -1272,7 +1026,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)
 
     def run_static_response_tests(self, exchange_name=None, test=None):
@@ -1670,13 +1425,3 @@ class testMainClass(baseMainTestClass):
         assert broker_id == id, 'vertex - id: ' + str(id) + ' different from  broker_id: ' + str(broker_id)
         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
-    (testMainClass().init(argv.exchange, argvSymbol, argvMethod))

ccxt/timex.py

@@ -723,7 +723,7 @@ class timex(Exchange, ImplicitAPI):
         :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/tokocrypto.py

@@ -1564,7 +1564,7 @@ class tokocrypto(Exchange, ImplicitAPI):
         :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 float [params.triggerPrice]: the price at which a trigger order would be triggered
         :param float [params.cost]: for spot market buy orders, the quote quantity that can be used alternative for the amount

ccxt/tradeogre.py

@@ -445,7 +445,7 @@ class tradeogre(Exchange, ImplicitAPI):
         :param str type: must be '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
+        :param float price: the price at which the order is to be fulfilled, in units of the quote currency
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """

ccxt/upbit.py

@@ -997,7 +997,7 @@ class upbit(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]: for market buy orders, the quote quantity that can be used alternative for the amount
         :param str [params.timeInForce]: 'IOC' or 'FOK'

ccxt/vertex.py

@@ -1565,7 +1565,7 @@ class vertex(Exchange, ImplicitAPI):
         :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.timeInForce]: ioc, fok
         :param bool [params.postOnly]: True or False whether the order is post-only
@@ -1660,7 +1660,7 @@ class vertex(Exchange, ImplicitAPI):
         :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 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
         :param str [params.timeInForce]: ioc, fok
         :param bool [params.postOnly]: True or False whether the order is post-only

ccxt/wavesexchange.py

@@ -1220,7 +1220,7 @@ class wavesexchange(Exchange, ImplicitAPI):
         :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 float [params.stopPrice]: The price at which a stop order is triggered at
         :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`

ccxt/wazirx.py

@@ -812,7 +812,7 @@ class wazirx(Exchange, ImplicitAPI):
         :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/whitebit.py

@@ -1200,7 +1200,7 @@ class whitebit(Exchange, ImplicitAPI):
         :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 float [params.cost]: *market orders only* the cost of the order in units of the base currency
         :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
@@ -1281,7 +1281,7 @@ class whitebit(Exchange, ImplicitAPI):
         :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 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/woo.py

@@ -52,7 +52,7 @@ class woo(Exchange, ImplicitAPI):
                 'createMarketBuyOrderWithCost': True,
                 'createMarketOrder': False,
                 'createMarketOrderWithCost': False,
-                'createMarketSellOrderWithCost': False,
+                'createMarketSellOrderWithCost': True,
                 'createOrder': True,
                 'createOrderWithTakeProfitAndStopLoss': True,
                 'createReduceOnlyOrder': True,
@@ -832,8 +832,22 @@ class woo(Exchange, ImplicitAPI):
         market = self.market(symbol)
         if not market['spot']:
             raise NotSupported(self.id + ' createMarketBuyOrderWithCost() supports spot orders only')
-        params['createMarketBuyOrderRequiresPrice'] = False
-        return self.create_order(symbol, 'market', 'buy', cost, None, params)
+        return self.create_order(symbol, 'market', 'buy', cost, 1, params)
+
+    def create_market_sell_order_with_cost(self, symbol: str, cost: float, params={}):
+        """
+        create a market sell order by providing the symbol and cost
+        :see: https://docs.woo.org/#send-order
+        :param str symbol: unified symbol of the market to create an order in
+        :param float cost: how much you want to trade in units of the quote currency
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
+        """
+        self.load_markets()
+        market = self.market(symbol)
+        if not market['spot']:
+            raise NotSupported(self.id + ' createMarketSellOrderWithCost() supports spot orders only')
+        return self.create_order(symbol, 'market', 'sell', cost, 1, params)
 
     def create_trailing_amount_order(self, symbol: str, type: OrderType, side: OrderSide, amount: float, price: Num = None, trailingAmount=None, trailingTriggerPrice=None, params={}) -> Order:
         """
@@ -888,7 +902,7 @@ class woo(Exchange, ImplicitAPI):
         :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 float [params.triggerPrice]: The price a trigger order is triggered at
         :param dict [params.takeProfit]: *takeProfit object in params* containing the triggerPrice at which the attached take profit order will be triggered(perpetual swap markets only)
@@ -941,28 +955,22 @@ class woo(Exchange, ImplicitAPI):
                 request['order_type'] = 'IOC'
         if reduceOnly:
             request[reduceOnlyKey] = reduceOnly
-        if price is not None:
+        if not isMarket and price is not None:
             request[priceKey] = self.price_to_precision(symbol, price)
         if isMarket and not isStop:
             # for market buy it requires the amount of quote currency to spend
-            if market['spot'] and orderSide == 'BUY':
+            cost = self.safe_string_2(params, 'cost', 'order_amount')
+            params = self.omit(params, ['cost', 'order_amount'])
+            isPriceProvided = price is not None
+            if market['spot'] and (isPriceProvided or (cost is not None)):
                 quoteAmount = None
-                createMarketBuyOrderRequiresPrice = True
-                createMarketBuyOrderRequiresPrice, params = self.handle_option_and_params(params, 'createOrder', 'createMarketBuyOrderRequiresPrice', True)
-                cost = self.safe_number_2(params, 'cost', 'order_amount')
-                params = self.omit(params, ['cost', 'order_amount'])
                 if cost is not None:
                     quoteAmount = self.cost_to_precision(symbol, cost)
-                elif createMarketBuyOrderRequiresPrice:
-                    if price is None:
-                        raise InvalidOrder(self.id + ' createOrder() requires the price argument for market buy orders to calculate the total cost to spend(amount * price), alternatively set the createMarketBuyOrderRequiresPrice option or param to False and pass the cost to spend(quote quantity) in the amount argument')
-                    else:
-                        amountString = self.number_to_string(amount)
-                        priceString = self.number_to_string(price)
-                        costRequest = Precise.string_mul(amountString, priceString)
-                        quoteAmount = self.cost_to_precision(symbol, costRequest)
                 else:
-                    quoteAmount = self.cost_to_precision(symbol, amount)
+                    amountString = self.number_to_string(amount)
+                    priceString = self.number_to_string(price)
+                    costRequest = Precise.string_mul(amountString, priceString)
+                    quoteAmount = self.cost_to_precision(symbol, costRequest)
                 request['order_amount'] = quoteAmount
             else:
                 request['order_quantity'] = self.amount_to_precision(symbol, amount)
@@ -1066,7 +1074,7 @@ class woo(Exchange, ImplicitAPI):
         :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 float [params.triggerPrice]: The price a trigger order is triggered at
         :param float [params.stopLossPrice]: price to trigger stop-loss orders
@@ -1496,8 +1504,8 @@ class woo(Exchange, ImplicitAPI):
         side = self.safe_string_lower(order, 'side')
         filled = self.omit_zero(self.safe_value_2(order, 'executed', 'totalExecutedQuantity'))
         average = self.omit_zero(self.safe_string_2(order, 'average_executed_price', 'averageExecutedPrice'))
-        remaining = Precise.string_sub(cost, filled)
-        fee = self.safe_value_2(order, 'total_fee', 'totalFee')
+        # remaining = Precise.string_sub(cost, filled)
+        fee = self.safe_number_2(order, 'total_fee', 'totalFee')
         feeCurrency = self.safe_string_2(order, 'fee_asset', 'feeAsset')
         transactions = self.safe_value(order, 'Transactions')
         stopPrice = self.safe_number(order, 'triggerPrice')
@@ -1536,7 +1544,7 @@ class woo(Exchange, ImplicitAPI):
             'average': average,
             'amount': amount,
             'filled': filled,
-            'remaining': remaining,  # TO_DO
+            'remaining': None,  # TO_DO
             'cost': cost,
             'trades': transactions,
             'fee': {

ccxt/woofipro.py

@@ -1196,7 +1196,7 @@ class woofipro(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 that the order is to be fullfilled, in units of the quote currency, ignored in market orders
+        :param float [price]: the price that 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: request to be sent to the exchange
         """
@@ -1283,7 +1283,7 @@ class woofipro(Exchange, ImplicitAPI):
         :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 float [params.triggerPrice]: The price a trigger order is triggered at
         :param dict [params.takeProfit]: *takeProfit object in params* containing the triggerPrice at which the attached take profit order will be triggered(perpetual swap markets only)
@@ -1400,7 +1400,7 @@ class woofipro(Exchange, ImplicitAPI):
         :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 float [params.triggerPrice]: The price a trigger order is triggered at
         :param float [params.stopLossPrice]: price to trigger stop-loss orders

ccxt/yobit.py

@@ -760,7 +760,7 @@ class yobit(Exchange, ImplicitAPI):
         :param str type: must be '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/zaif.py

@@ -429,7 +429,7 @@ class zaif(Exchange, ImplicitAPI):
         :param str type: must be '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/zonda.py

@@ -1323,7 +1323,7 @@ class zonda(Exchange, ImplicitAPI):
         :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>`
         """