tzquant_zq
/
tz_crypto_pub

# coding: utf-8
"""
    Gate API v4
    Welcome to Gate.io API  APIv4 provides spot, margin and futures trading operations. There are public APIs to retrieve the real-time market statistics, and private APIs which needs authentication to trade on user's behalf.  # noqa: E501
    Contact: support@mail.gate.io    Generated by: https://openapi-generator.tech"""


from __future__ import absolute_import
import re  # noqa: F401
# python 2 and python 3 compatibility libraryimport six
from gate_api.api_client import ApiClientfrom gate_api.exceptions import ApiTypeError, ApiValueError  # noqa: F401

class WalletApi(object):    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech
    Do not edit the class manually.    """

    def __init__(self, api_client=None):        if api_client is None:            api_client = ApiClient()        self.api_client = api_client
    def list_currency_chains(self, currency, **kwargs):  # noqa: E501        """List chains supported for specified currency  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an        asynchronous HTTP request, please pass async_req=True        >>> thread = api.list_currency_chains(currency, async_req=True)        >>> result = thread.get()
        :param bool async_req: execute request asynchronously        :param str currency: Currency name (required)        :param _preload_content: if False, the urllib3.HTTPResponse object will                                 be returned without reading/decoding response                                 data. Default is True.        :param _request_timeout: timeout setting for this request. If one                                 number provided, it will be total request                                 timeout. It can also be a pair (tuple) of                                 (connection, read) timeouts.        :rtype: list[gate_api.CurrencyChain]        :return: If the method is called asynchronously,                 returns the request thread.        """
        kwargs['_return_http_data_only'] = True        return self.list_currency_chains_with_http_info(currency, **kwargs)  # noqa: E501
    def list_currency_chains_with_http_info(self, currency, **kwargs):  # noqa: E501        """List chains supported for specified currency  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an        asynchronous HTTP request, please pass async_req=True        >>> thread = api.list_currency_chains_with_http_info(currency, async_req=True)        >>> result = thread.get()
        :param bool async_req: execute request asynchronously        :param str currency: Currency name (required)        :param _return_http_data_only: response data without head status code                                       and headers        :param _preload_content: if False, the urllib3.HTTPResponse object will                                 be returned without reading/decoding response                                 data. Default is True.        :param _request_timeout: timeout setting for this request. If one                                 number provided, it will be total request                                 timeout. It can also be a pair (tuple) of                                 (connection, read) timeouts.        :rtype: tuple(list[gate_api.CurrencyChain], status_code(int), headers(HTTPHeaderDict))        :return: If the method is called asynchronously,                 returns the request thread.        """

        local_var_params = locals()
        all_params = ['currency']        all_params.extend(['async_req', '_return_http_data_only', '_preload_content', '_request_timeout'])
        for k, v in six.iteritems(local_var_params['kwargs']):            if k not in all_params:                raise ApiTypeError("Got an unexpected keyword argument '%s'" " to method list_currency_chains" % k)            local_var_params[k] = v        del local_var_params['kwargs']        # verify the required parameter 'currency' is set        if self.api_client.client_side_validation and (            'currency' not in local_var_params or local_var_params['currency'] is None  # noqa: E501        ):  # noqa: E501            raise ApiValueError(                "Missing the required parameter `currency` when calling `list_currency_chains`"            )  # noqa: E501
        collection_formats = {}
        path_params = {}
        query_params = []        if 'currency' in local_var_params and local_var_params['currency'] is not None:  # noqa: E501            query_params.append(('currency', local_var_params['currency']))  # noqa: E501
        header_params = {}
        form_params = []        local_var_files = {}
        body_params = None        # HTTP header `Accept`        header_params['Accept'] = self.api_client.select_header_accept(['application/json'])  # noqa: E501
        # Authentication setting        auth_settings = []  # noqa: E501
        return self.api_client.call_api(            '/wallet/currency_chains',            'GET',            path_params,            query_params,            header_params,            body=body_params,            post_params=form_params,            files=local_var_files,            response_type='list[CurrencyChain]',  # noqa: E501            auth_settings=auth_settings,            async_req=local_var_params.get('async_req'),            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501            _preload_content=local_var_params.get('_preload_content', True),            _request_timeout=local_var_params.get('_request_timeout'),            collection_formats=collection_formats,        )
    def get_deposit_address(self, currency, **kwargs):  # noqa: E501        """Generate currency deposit address  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an        asynchronous HTTP request, please pass async_req=True        >>> thread = api.get_deposit_address(currency, async_req=True)        >>> result = thread.get()
        :param bool async_req: execute request asynchronously        :param str currency: Currency name (required)        :param _preload_content: if False, the urllib3.HTTPResponse object will                                 be returned without reading/decoding response                                 data. Default is True.        :param _request_timeout: timeout setting for this request. If one                                 number provided, it will be total request                                 timeout. It can also be a pair (tuple) of                                 (connection, read) timeouts.        :rtype: gate_api.DepositAddress        :return: If the method is called asynchronously,                 returns the request thread.        """
        kwargs['_return_http_data_only'] = True        return self.get_deposit_address_with_http_info(currency, **kwargs)  # noqa: E501
    def get_deposit_address_with_http_info(self, currency, **kwargs):  # noqa: E501        """Generate currency deposit address  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an        asynchronous HTTP request, please pass async_req=True        >>> thread = api.get_deposit_address_with_http_info(currency, async_req=True)        >>> result = thread.get()
        :param bool async_req: execute request asynchronously        :param str currency: Currency name (required)        :param _return_http_data_only: response data without head status code                                       and headers        :param _preload_content: if False, the urllib3.HTTPResponse object will                                 be returned without reading/decoding response                                 data. Default is True.        :param _request_timeout: timeout setting for this request. If one                                 number provided, it will be total request                                 timeout. It can also be a pair (tuple) of                                 (connection, read) timeouts.        :rtype: tuple(gate_api.DepositAddress, status_code(int), headers(HTTPHeaderDict))        :return: If the method is called asynchronously,                 returns the request thread.        """

        local_var_params = locals()
        all_params = ['currency']        all_params.extend(['async_req', '_return_http_data_only', '_preload_content', '_request_timeout'])
        for k, v in six.iteritems(local_var_params['kwargs']):            if k not in all_params:                raise ApiTypeError("Got an unexpected keyword argument '%s'" " to method get_deposit_address" % k)            local_var_params[k] = v        del local_var_params['kwargs']        # verify the required parameter 'currency' is set        if self.api_client.client_side_validation and (            'currency' not in local_var_params or local_var_params['currency'] is None  # noqa: E501        ):  # noqa: E501            raise ApiValueError(                "Missing the required parameter `currency` when calling `get_deposit_address`"            )  # noqa: E501
        collection_formats = {}
        path_params = {}
        query_params = []        if 'currency' in local_var_params and local_var_params['currency'] is not None:  # noqa: E501            query_params.append(('currency', local_var_params['currency']))  # noqa: E501
        header_params = {}
        form_params = []        local_var_files = {}
        body_params = None        # HTTP header `Accept`        header_params['Accept'] = self.api_client.select_header_accept(['application/json'])  # noqa: E501
        # Authentication setting        auth_settings = ['apiv4']  # noqa: E501
        return self.api_client.call_api(            '/wallet/deposit_address',            'GET',            path_params,            query_params,            header_params,            body=body_params,            post_params=form_params,            files=local_var_files,            response_type='DepositAddress',  # noqa: E501            auth_settings=auth_settings,            async_req=local_var_params.get('async_req'),            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501            _preload_content=local_var_params.get('_preload_content', True),            _request_timeout=local_var_params.get('_request_timeout'),            collection_formats=collection_formats,        )
    def list_withdrawals(self, **kwargs):  # noqa: E501        """Retrieve withdrawal records  # noqa: E501

        Record time range cannot exceed 30 days  # noqa: E501        This method makes a synchronous HTTP request by default. To make an        asynchronous HTTP request, please pass async_req=True        >>> thread = api.list_withdrawals(async_req=True)        >>> result = thread.get()
        :param bool async_req: execute request asynchronously        :param str currency: Filter by currency. Return all currency records if not specified        :param int _from: Time range beginning, default to 7 days before current time        :param int to: Time range ending, default to current time        :param int limit: Maximum number of records to be returned in a single list        :param int offset: List offset, starting from 0        :param _preload_content: if False, the urllib3.HTTPResponse object will                                 be returned without reading/decoding response                                 data. Default is True.        :param _request_timeout: timeout setting for this request. If one                                 number provided, it will be total request                                 timeout. It can also be a pair (tuple) of                                 (connection, read) timeouts.        :rtype: list[gate_api.LedgerRecord]        :return: If the method is called asynchronously,                 returns the request thread.        """
        kwargs['_return_http_data_only'] = True        return self.list_withdrawals_with_http_info(**kwargs)  # noqa: E501
    def list_withdrawals_with_http_info(self, **kwargs):  # noqa: E501        """Retrieve withdrawal records  # noqa: E501

        Record time range cannot exceed 30 days  # noqa: E501        This method makes a synchronous HTTP request by default. To make an        asynchronous HTTP request, please pass async_req=True        >>> thread = api.list_withdrawals_with_http_info(async_req=True)        >>> result = thread.get()
        :param bool async_req: execute request asynchronously        :param str currency: Filter by currency. Return all currency records if not specified        :param int _from: Time range beginning, default to 7 days before current time        :param int to: Time range ending, default to current time        :param int limit: Maximum number of records to be returned in a single list        :param int offset: List offset, starting from 0        :param _return_http_data_only: response data without head status code                                       and headers        :param _preload_content: if False, the urllib3.HTTPResponse object will                                 be returned without reading/decoding response                                 data. Default is True.        :param _request_timeout: timeout setting for this request. If one                                 number provided, it will be total request                                 timeout. It can also be a pair (tuple) of                                 (connection, read) timeouts.        :rtype: tuple(list[gate_api.LedgerRecord], status_code(int), headers(HTTPHeaderDict))        :return: If the method is called asynchronously,                 returns the request thread.        """

        local_var_params = locals()
        all_params = ['currency', '_from', 'to', 'limit', 'offset']        all_params.extend(['async_req', '_return_http_data_only', '_preload_content', '_request_timeout'])
        for k, v in six.iteritems(local_var_params['kwargs']):            if k not in all_params:                raise ApiTypeError("Got an unexpected keyword argument '%s'" " to method list_withdrawals" % k)            local_var_params[k] = v        del local_var_params['kwargs']
        if (            self.api_client.client_side_validation and 'limit' in local_var_params and local_var_params['limit'] > 1000        ):  # noqa: E501            raise ApiValueError(                "Invalid value for parameter `limit` when calling `list_withdrawals`, must be a value less than or equal to `1000`"            )  # noqa: E501        if (            self.api_client.client_side_validation and 'limit' in local_var_params and local_var_params['limit'] < 1        ):  # noqa: E501            raise ApiValueError(                "Invalid value for parameter `limit` when calling `list_withdrawals`, must be a value greater than or equal to `1`"            )  # noqa: E501        if (            self.api_client.client_side_validation and 'offset' in local_var_params and local_var_params['offset'] < 0        ):  # noqa: E501            raise ApiValueError(                "Invalid value for parameter `offset` when calling `list_withdrawals`, must be a value greater than or equal to `0`"            )  # noqa: E501        collection_formats = {}
        path_params = {}
        query_params = []        if 'currency' in local_var_params and local_var_params['currency'] is not None:  # noqa: E501            query_params.append(('currency', local_var_params['currency']))  # noqa: E501        if '_from' in local_var_params and local_var_params['_from'] is not None:  # noqa: E501            query_params.append(('from', local_var_params['_from']))  # noqa: E501        if 'to' in local_var_params and local_var_params['to'] is not None:  # noqa: E501            query_params.append(('to', local_var_params['to']))  # noqa: E501        if 'limit' in local_var_params and local_var_params['limit'] is not None:  # noqa: E501            query_params.append(('limit', local_var_params['limit']))  # noqa: E501        if 'offset' in local_var_params and local_var_params['offset'] is not None:  # noqa: E501            query_params.append(('offset', local_var_params['offset']))  # noqa: E501
        header_params = {}
        form_params = []        local_var_files = {}
        body_params = None        # HTTP header `Accept`        header_params['Accept'] = self.api_client.select_header_accept(['application/json'])  # noqa: E501
        # Authentication setting        auth_settings = ['apiv4']  # noqa: E501
        return self.api_client.call_api(            '/wallet/withdrawals',            'GET',            path_params,            query_params,            header_params,            body=body_params,            post_params=form_params,            files=local_var_files,            response_type='list[LedgerRecord]',  # noqa: E501            auth_settings=auth_settings,            async_req=local_var_params.get('async_req'),            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501            _preload_content=local_var_params.get('_preload_content', True),            _request_timeout=local_var_params.get('_request_timeout'),            collection_formats=collection_formats,        )
    def list_deposits(self, **kwargs):  # noqa: E501        """Retrieve deposit records  # noqa: E501

        Record time range cannot exceed 30 days  # noqa: E501        This method makes a synchronous HTTP request by default. To make an        asynchronous HTTP request, please pass async_req=True        >>> thread = api.list_deposits(async_req=True)        >>> result = thread.get()
        :param bool async_req: execute request asynchronously        :param str currency: Filter by currency. Return all currency records if not specified        :param int _from: Time range beginning, default to 7 days before current time        :param int to: Time range ending, default to current time        :param int limit: Maximum number of records to be returned in a single list        :param int offset: List offset, starting from 0        :param _preload_content: if False, the urllib3.HTTPResponse object will                                 be returned without reading/decoding response                                 data. Default is True.        :param _request_timeout: timeout setting for this request. If one                                 number provided, it will be total request                                 timeout. It can also be a pair (tuple) of                                 (connection, read) timeouts.        :rtype: list[gate_api.LedgerRecord]        :return: If the method is called asynchronously,                 returns the request thread.        """
        kwargs['_return_http_data_only'] = True        return self.list_deposits_with_http_info(**kwargs)  # noqa: E501
    def list_deposits_with_http_info(self, **kwargs):  # noqa: E501        """Retrieve deposit records  # noqa: E501

        Record time range cannot exceed 30 days  # noqa: E501        This method makes a synchronous HTTP request by default. To make an        asynchronous HTTP request, please pass async_req=True        >>> thread = api.list_deposits_with_http_info(async_req=True)        >>> result = thread.get()
        :param bool async_req: execute request asynchronously        :param str currency: Filter by currency. Return all currency records if not specified        :param int _from: Time range beginning, default to 7 days before current time        :param int to: Time range ending, default to current time        :param int limit: Maximum number of records to be returned in a single list        :param int offset: List offset, starting from 0        :param _return_http_data_only: response data without head status code                                       and headers        :param _preload_content: if False, the urllib3.HTTPResponse object will                                 be returned without reading/decoding response                                 data. Default is True.        :param _request_timeout: timeout setting for this request. If one                                 number provided, it will be total request                                 timeout. It can also be a pair (tuple) of                                 (connection, read) timeouts.        :rtype: tuple(list[gate_api.LedgerRecord], status_code(int), headers(HTTPHeaderDict))        :return: If the method is called asynchronously,                 returns the request thread.        """

        local_var_params = locals()
        all_params = ['currency', '_from', 'to', 'limit', 'offset']        all_params.extend(['async_req', '_return_http_data_only', '_preload_content', '_request_timeout'])
        for k, v in six.iteritems(local_var_params['kwargs']):            if k not in all_params:                raise ApiTypeError("Got an unexpected keyword argument '%s'" " to method list_deposits" % k)            local_var_params[k] = v        del local_var_params['kwargs']
        if (            self.api_client.client_side_validation and 'limit' in local_var_params and local_var_params['limit'] > 1000        ):  # noqa: E501            raise ApiValueError(                "Invalid value for parameter `limit` when calling `list_deposits`, must be a value less than or equal to `1000`"            )  # noqa: E501        if (            self.api_client.client_side_validation and 'limit' in local_var_params and local_var_params['limit'] < 1        ):  # noqa: E501            raise ApiValueError(                "Invalid value for parameter `limit` when calling `list_deposits`, must be a value greater than or equal to `1`"            )  # noqa: E501        if (            self.api_client.client_side_validation and 'offset' in local_var_params and local_var_params['offset'] < 0        ):  # noqa: E501            raise ApiValueError(                "Invalid value for parameter `offset` when calling `list_deposits`, must be a value greater than or equal to `0`"            )  # noqa: E501        collection_formats = {}
        path_params = {}
        query_params = []        if 'currency' in local_var_params and local_var_params['currency'] is not None:  # noqa: E501            query_params.append(('currency', local_var_params['currency']))  # noqa: E501        if '_from' in local_var_params and local_var_params['_from'] is not None:  # noqa: E501            query_params.append(('from', local_var_params['_from']))  # noqa: E501        if 'to' in local_var_params and local_var_params['to'] is not None:  # noqa: E501            query_params.append(('to', local_var_params['to']))  # noqa: E501        if 'limit' in local_var_params and local_var_params['limit'] is not None:  # noqa: E501            query_params.append(('limit', local_var_params['limit']))  # noqa: E501        if 'offset' in local_var_params and local_var_params['offset'] is not None:  # noqa: E501            query_params.append(('offset', local_var_params['offset']))  # noqa: E501
        header_params = {}
        form_params = []        local_var_files = {}
        body_params = None        # HTTP header `Accept`        header_params['Accept'] = self.api_client.select_header_accept(['application/json'])  # noqa: E501
        # Authentication setting        auth_settings = ['apiv4']  # noqa: E501
        return self.api_client.call_api(            '/wallet/deposits',            'GET',            path_params,            query_params,            header_params,            body=body_params,            post_params=form_params,            files=local_var_files,            response_type='list[LedgerRecord]',  # noqa: E501            auth_settings=auth_settings,            async_req=local_var_params.get('async_req'),            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501            _preload_content=local_var_params.get('_preload_content', True),            _request_timeout=local_var_params.get('_request_timeout'),            collection_formats=collection_formats,        )
    def transfer(self, transfer, **kwargs):  # noqa: E501        """Transfer between trading accounts  # noqa: E501

        Transfer between different accounts. Currently support transfers between the following:  1. spot - margin 2. spot - futures(perpetual) 3. spot - delivery 4. spot - cross margin 5. spot - options  # noqa: E501        This method makes a synchronous HTTP request by default. To make an        asynchronous HTTP request, please pass async_req=True        >>> thread = api.transfer(transfer, async_req=True)        >>> result = thread.get()
        :param bool async_req: execute request asynchronously        :param Transfer transfer: (required)        :param _preload_content: if False, the urllib3.HTTPResponse object will                                 be returned without reading/decoding response                                 data. Default is True.        :param _request_timeout: timeout setting for this request. If one                                 number provided, it will be total request                                 timeout. It can also be a pair (tuple) of                                 (connection, read) timeouts.        :rtype: gate_api.TransactionID        :return: If the method is called asynchronously,                 returns the request thread.        """
        kwargs['_return_http_data_only'] = True        return self.transfer_with_http_info(transfer, **kwargs)  # noqa: E501
    def transfer_with_http_info(self, transfer, **kwargs):  # noqa: E501        """Transfer between trading accounts  # noqa: E501

        Transfer between different accounts. Currently support transfers between the following:  1. spot - margin 2. spot - futures(perpetual) 3. spot - delivery 4. spot - cross margin 5. spot - options  # noqa: E501        This method makes a synchronous HTTP request by default. To make an        asynchronous HTTP request, please pass async_req=True        >>> thread = api.transfer_with_http_info(transfer, async_req=True)        >>> result = thread.get()
        :param bool async_req: execute request asynchronously        :param Transfer transfer: (required)        :param _return_http_data_only: response data without head status code                                       and headers        :param _preload_content: if False, the urllib3.HTTPResponse object will                                 be returned without reading/decoding response                                 data. Default is True.        :param _request_timeout: timeout setting for this request. If one                                 number provided, it will be total request                                 timeout. It can also be a pair (tuple) of                                 (connection, read) timeouts.        :rtype: tuple(gate_api.TransactionID, status_code(int), headers(HTTPHeaderDict))        :return: If the method is called asynchronously,                 returns the request thread.        """

        local_var_params = locals()
        all_params = ['transfer']        all_params.extend(['async_req', '_return_http_data_only', '_preload_content', '_request_timeout'])
        for k, v in six.iteritems(local_var_params['kwargs']):            if k not in all_params:                raise ApiTypeError("Got an unexpected keyword argument '%s'" " to method transfer" % k)            local_var_params[k] = v        del local_var_params['kwargs']        # verify the required parameter 'transfer' is set        if self.api_client.client_side_validation and (            'transfer' not in local_var_params or local_var_params['transfer'] is None  # noqa: E501        ):  # noqa: E501            raise ApiValueError("Missing the required parameter `transfer` when calling `transfer`")  # noqa: E501
        collection_formats = {}
        path_params = {}
        query_params = []
        header_params = {}
        form_params = []        local_var_files = {}
        body_params = None        if 'transfer' in local_var_params:            body_params = local_var_params['transfer']        # HTTP header `Accept`        header_params['Accept'] = self.api_client.select_header_accept(['application/json'])  # noqa: E501
        # HTTP header `Content-Type`        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501            ['application/json']        )  # noqa: E501
        # Authentication setting        auth_settings = ['apiv4']  # noqa: E501
        return self.api_client.call_api(            '/wallet/transfers',            'POST',            path_params,            query_params,            header_params,            body=body_params,            post_params=form_params,            files=local_var_files,            response_type='TransactionID',  # noqa: E501            auth_settings=auth_settings,            async_req=local_var_params.get('async_req'),            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501            _preload_content=local_var_params.get('_preload_content', True),            _request_timeout=local_var_params.get('_request_timeout'),            collection_formats=collection_formats,        )
    def list_sub_account_transfers(self, **kwargs):  # noqa: E501        """Retrieve transfer records between main and sub accounts  # noqa: E501

        Record time range cannot exceed 30 days  > Note: only records after 2020-04-10 can be retrieved  # noqa: E501        This method makes a synchronous HTTP request by default. To make an        asynchronous HTTP request, please pass async_req=True        >>> thread = api.list_sub_account_transfers(async_req=True)        >>> result = thread.get()
        :param bool async_req: execute request asynchronously        :param str sub_uid: User ID of sub-account, you can query multiple records separated by `,`. If not specified, it will return the records of all sub accounts        :param int _from: Time range beginning, default to 7 days before current time        :param int to: Time range ending, default to current time        :param int limit: Maximum number of records to be returned in a single list        :param int offset: List offset, starting from 0        :param _preload_content: if False, the urllib3.HTTPResponse object will                                 be returned without reading/decoding response                                 data. Default is True.        :param _request_timeout: timeout setting for this request. If one                                 number provided, it will be total request                                 timeout. It can also be a pair (tuple) of                                 (connection, read) timeouts.        :rtype: list[gate_api.SubAccountTransfer]        :return: If the method is called asynchronously,                 returns the request thread.        """
        kwargs['_return_http_data_only'] = True        return self.list_sub_account_transfers_with_http_info(**kwargs)  # noqa: E501
    def list_sub_account_transfers_with_http_info(self, **kwargs):  # noqa: E501        """Retrieve transfer records between main and sub accounts  # noqa: E501

        Record time range cannot exceed 30 days  > Note: only records after 2020-04-10 can be retrieved  # noqa: E501        This method makes a synchronous HTTP request by default. To make an        asynchronous HTTP request, please pass async_req=True        >>> thread = api.list_sub_account_transfers_with_http_info(async_req=True)        >>> result = thread.get()
        :param bool async_req: execute request asynchronously        :param str sub_uid: User ID of sub-account, you can query multiple records separated by `,`. If not specified, it will return the records of all sub accounts        :param int _from: Time range beginning, default to 7 days before current time        :param int to: Time range ending, default to current time        :param int limit: Maximum number of records to be returned in a single list        :param int offset: List offset, starting from 0        :param _return_http_data_only: response data without head status code                                       and headers        :param _preload_content: if False, the urllib3.HTTPResponse object will                                 be returned without reading/decoding response                                 data. Default is True.        :param _request_timeout: timeout setting for this request. If one                                 number provided, it will be total request                                 timeout. It can also be a pair (tuple) of                                 (connection, read) timeouts.        :rtype: tuple(list[gate_api.SubAccountTransfer], status_code(int), headers(HTTPHeaderDict))        :return: If the method is called asynchronously,                 returns the request thread.        """

        local_var_params = locals()
        all_params = ['sub_uid', '_from', 'to', 'limit', 'offset']        all_params.extend(['async_req', '_return_http_data_only', '_preload_content', '_request_timeout'])
        for k, v in six.iteritems(local_var_params['kwargs']):            if k not in all_params:                raise ApiTypeError(                    "Got an unexpected keyword argument '%s'" " to method list_sub_account_transfers" % k                )            local_var_params[k] = v        del local_var_params['kwargs']
        if (            self.api_client.client_side_validation and 'limit' in local_var_params and local_var_params['limit'] > 1000        ):  # noqa: E501            raise ApiValueError(                "Invalid value for parameter `limit` when calling `list_sub_account_transfers`, must be a value less than or equal to `1000`"            )  # noqa: E501        if (            self.api_client.client_side_validation and 'limit' in local_var_params and local_var_params['limit'] < 1        ):  # noqa: E501            raise ApiValueError(                "Invalid value for parameter `limit` when calling `list_sub_account_transfers`, must be a value greater than or equal to `1`"            )  # noqa: E501        if (            self.api_client.client_side_validation and 'offset' in local_var_params and local_var_params['offset'] < 0        ):  # noqa: E501            raise ApiValueError(                "Invalid value for parameter `offset` when calling `list_sub_account_transfers`, must be a value greater than or equal to `0`"            )  # noqa: E501        collection_formats = {}
        path_params = {}
        query_params = []        if 'sub_uid' in local_var_params and local_var_params['sub_uid'] is not None:  # noqa: E501            query_params.append(('sub_uid', local_var_params['sub_uid']))  # noqa: E501        if '_from' in local_var_params and local_var_params['_from'] is not None:  # noqa: E501            query_params.append(('from', local_var_params['_from']))  # noqa: E501        if 'to' in local_var_params and local_var_params['to'] is not None:  # noqa: E501            query_params.append(('to', local_var_params['to']))  # noqa: E501        if 'limit' in local_var_params and local_var_params['limit'] is not None:  # noqa: E501            query_params.append(('limit', local_var_params['limit']))  # noqa: E501        if 'offset' in local_var_params and local_var_params['offset'] is not None:  # noqa: E501            query_params.append(('offset', local_var_params['offset']))  # noqa: E501
        header_params = {}
        form_params = []        local_var_files = {}
        body_params = None        # HTTP header `Accept`        header_params['Accept'] = self.api_client.select_header_accept(['application/json'])  # noqa: E501
        # Authentication setting        auth_settings = ['apiv4']  # noqa: E501
        return self.api_client.call_api(            '/wallet/sub_account_transfers',            'GET',            path_params,            query_params,            header_params,            body=body_params,            post_params=form_params,            files=local_var_files,            response_type='list[SubAccountTransfer]',  # noqa: E501            auth_settings=auth_settings,            async_req=local_var_params.get('async_req'),            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501            _preload_content=local_var_params.get('_preload_content', True),            _request_timeout=local_var_params.get('_request_timeout'),            collection_formats=collection_formats,        )
    def transfer_with_sub_account(self, sub_account_transfer, **kwargs):  # noqa: E501        """Transfer between main and sub accounts  # noqa: E501

        Support transferring with sub user's spot or futures account. Note that only main user's spot account is used no matter which sub user's account is operated.  # noqa: E501        This method makes a synchronous HTTP request by default. To make an        asynchronous HTTP request, please pass async_req=True        >>> thread = api.transfer_with_sub_account(sub_account_transfer, async_req=True)        >>> result = thread.get()
        :param bool async_req: execute request asynchronously        :param SubAccountTransfer sub_account_transfer: (required)        :param _preload_content: if False, the urllib3.HTTPResponse object will                                 be returned without reading/decoding response                                 data. Default is True.        :param _request_timeout: timeout setting for this request. If one                                 number provided, it will be total request                                 timeout. It can also be a pair (tuple) of                                 (connection, read) timeouts.        :rtype: None        :return: If the method is called asynchronously,                 returns the request thread.        """
        kwargs['_return_http_data_only'] = True        return self.transfer_with_sub_account_with_http_info(sub_account_transfer, **kwargs)  # noqa: E501
    def transfer_with_sub_account_with_http_info(self, sub_account_transfer, **kwargs):  # noqa: E501        """Transfer between main and sub accounts  # noqa: E501

        Support transferring with sub user's spot or futures account. Note that only main user's spot account is used no matter which sub user's account is operated.  # noqa: E501        This method makes a synchronous HTTP request by default. To make an        asynchronous HTTP request, please pass async_req=True        >>> thread = api.transfer_with_sub_account_with_http_info(sub_account_transfer, async_req=True)        >>> result = thread.get()
        :param bool async_req: execute request asynchronously        :param SubAccountTransfer sub_account_transfer: (required)        :param _return_http_data_only: response data without head status code                                       and headers        :param _preload_content: if False, the urllib3.HTTPResponse object will                                 be returned without reading/decoding response                                 data. Default is True.        :param _request_timeout: timeout setting for this request. If one                                 number provided, it will be total request                                 timeout. It can also be a pair (tuple) of                                 (connection, read) timeouts.        :rtype: None        :return: If the method is called asynchronously,                 returns the request thread.        """

        local_var_params = locals()
        all_params = ['sub_account_transfer']        all_params.extend(['async_req', '_return_http_data_only', '_preload_content', '_request_timeout'])
        for k, v in six.iteritems(local_var_params['kwargs']):            if k not in all_params:                raise ApiTypeError("Got an unexpected keyword argument '%s'" " to method transfer_with_sub_account" % k)            local_var_params[k] = v        del local_var_params['kwargs']        # verify the required parameter 'sub_account_transfer' is set        if self.api_client.client_side_validation and (            'sub_account_transfer' not in local_var_params            or local_var_params['sub_account_transfer'] is None  # noqa: E501        ):  # noqa: E501            raise ApiValueError(                "Missing the required parameter `sub_account_transfer` when calling `transfer_with_sub_account`"            )  # noqa: E501
        collection_formats = {}
        path_params = {}
        query_params = []
        header_params = {}
        form_params = []        local_var_files = {}
        body_params = None        if 'sub_account_transfer' in local_var_params:            body_params = local_var_params['sub_account_transfer']        # HTTP header `Content-Type`        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501            ['application/json']        )  # noqa: E501
        # Authentication setting        auth_settings = ['apiv4']  # noqa: E501
        return self.api_client.call_api(            '/wallet/sub_account_transfers',            'POST',            path_params,            query_params,            header_params,            body=body_params,            post_params=form_params,            files=local_var_files,            response_type=None,  # noqa: E501            auth_settings=auth_settings,            async_req=local_var_params.get('async_req'),            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501            _preload_content=local_var_params.get('_preload_content', True),            _request_timeout=local_var_params.get('_request_timeout'),            collection_formats=collection_formats,        )
    def sub_account_to_sub_account(self, sub_account_to_sub_account, **kwargs):  # noqa: E501        """Sub-account transfers to sub-account  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an        asynchronous HTTP request, please pass async_req=True        >>> thread = api.sub_account_to_sub_account(sub_account_to_sub_account, async_req=True)        >>> result = thread.get()
        :param bool async_req: execute request asynchronously        :param SubAccountToSubAccount sub_account_to_sub_account: (required)        :param _preload_content: if False, the urllib3.HTTPResponse object will                                 be returned without reading/decoding response                                 data. Default is True.        :param _request_timeout: timeout setting for this request. If one                                 number provided, it will be total request                                 timeout. It can also be a pair (tuple) of                                 (connection, read) timeouts.        :rtype: None        :return: If the method is called asynchronously,                 returns the request thread.        """
        kwargs['_return_http_data_only'] = True        return self.sub_account_to_sub_account_with_http_info(sub_account_to_sub_account, **kwargs)  # noqa: E501
    def sub_account_to_sub_account_with_http_info(self, sub_account_to_sub_account, **kwargs):  # noqa: E501        """Sub-account transfers to sub-account  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an        asynchronous HTTP request, please pass async_req=True        >>> thread = api.sub_account_to_sub_account_with_http_info(sub_account_to_sub_account, async_req=True)        >>> result = thread.get()
        :param bool async_req: execute request asynchronously        :param SubAccountToSubAccount sub_account_to_sub_account: (required)        :param _return_http_data_only: response data without head status code                                       and headers        :param _preload_content: if False, the urllib3.HTTPResponse object will                                 be returned without reading/decoding response                                 data. Default is True.        :param _request_timeout: timeout setting for this request. If one                                 number provided, it will be total request                                 timeout. It can also be a pair (tuple) of                                 (connection, read) timeouts.        :rtype: None        :return: If the method is called asynchronously,                 returns the request thread.        """

        local_var_params = locals()
        all_params = ['sub_account_to_sub_account']        all_params.extend(['async_req', '_return_http_data_only', '_preload_content', '_request_timeout'])
        for k, v in six.iteritems(local_var_params['kwargs']):            if k not in all_params:                raise ApiTypeError(                    "Got an unexpected keyword argument '%s'" " to method sub_account_to_sub_account" % k                )            local_var_params[k] = v        del local_var_params['kwargs']        # verify the required parameter 'sub_account_to_sub_account' is set        if self.api_client.client_side_validation and (            'sub_account_to_sub_account' not in local_var_params            or local_var_params['sub_account_to_sub_account'] is None  # noqa: E501        ):  # noqa: E501            raise ApiValueError(                "Missing the required parameter `sub_account_to_sub_account` when calling `sub_account_to_sub_account`"            )  # noqa: E501
        collection_formats = {}
        path_params = {}
        query_params = []
        header_params = {}
        form_params = []        local_var_files = {}
        body_params = None        if 'sub_account_to_sub_account' in local_var_params:            body_params = local_var_params['sub_account_to_sub_account']        # HTTP header `Content-Type`        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501            ['application/json']        )  # noqa: E501
        # Authentication setting        auth_settings = ['apiv4']  # noqa: E501
        return self.api_client.call_api(            '/wallet/sub_account_to_sub_account',            'POST',            path_params,            query_params,            header_params,            body=body_params,            post_params=form_params,            files=local_var_files,            response_type=None,  # noqa: E501            auth_settings=auth_settings,            async_req=local_var_params.get('async_req'),            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501            _preload_content=local_var_params.get('_preload_content', True),            _request_timeout=local_var_params.get('_request_timeout'),            collection_formats=collection_formats,        )
    def list_withdraw_status(self, **kwargs):  # noqa: E501        """Retrieve withdrawal status  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an        asynchronous HTTP request, please pass async_req=True        >>> thread = api.list_withdraw_status(async_req=True)        >>> result = thread.get()
        :param bool async_req: execute request asynchronously        :param str currency: Retrieve data of the specified currency        :param _preload_content: if False, the urllib3.HTTPResponse object will                                 be returned without reading/decoding response                                 data. Default is True.        :param _request_timeout: timeout setting for this request. If one                                 number provided, it will be total request                                 timeout. It can also be a pair (tuple) of                                 (connection, read) timeouts.        :rtype: list[gate_api.WithdrawStatus]        :return: If the method is called asynchronously,                 returns the request thread.        """
        kwargs['_return_http_data_only'] = True        return self.list_withdraw_status_with_http_info(**kwargs)  # noqa: E501
    def list_withdraw_status_with_http_info(self, **kwargs):  # noqa: E501        """Retrieve withdrawal status  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an        asynchronous HTTP request, please pass async_req=True        >>> thread = api.list_withdraw_status_with_http_info(async_req=True)        >>> result = thread.get()
        :param bool async_req: execute request asynchronously        :param str currency: Retrieve data of the specified currency        :param _return_http_data_only: response data without head status code                                       and headers        :param _preload_content: if False, the urllib3.HTTPResponse object will                                 be returned without reading/decoding response                                 data. Default is True.        :param _request_timeout: timeout setting for this request. If one                                 number provided, it will be total request                                 timeout. It can also be a pair (tuple) of                                 (connection, read) timeouts.        :rtype: tuple(list[gate_api.WithdrawStatus], status_code(int), headers(HTTPHeaderDict))        :return: If the method is called asynchronously,                 returns the request thread.        """

        local_var_params = locals()
        all_params = ['currency']        all_params.extend(['async_req', '_return_http_data_only', '_preload_content', '_request_timeout'])
        for k, v in six.iteritems(local_var_params['kwargs']):            if k not in all_params:                raise ApiTypeError("Got an unexpected keyword argument '%s'" " to method list_withdraw_status" % k)            local_var_params[k] = v        del local_var_params['kwargs']
        collection_formats = {}
        path_params = {}
        query_params = []        if 'currency' in local_var_params and local_var_params['currency'] is not None:  # noqa: E501            query_params.append(('currency', local_var_params['currency']))  # noqa: E501
        header_params = {}
        form_params = []        local_var_files = {}
        body_params = None        # HTTP header `Accept`        header_params['Accept'] = self.api_client.select_header_accept(['application/json'])  # noqa: E501
        # Authentication setting        auth_settings = ['apiv4']  # noqa: E501
        return self.api_client.call_api(            '/wallet/withdraw_status',            'GET',            path_params,            query_params,            header_params,            body=body_params,            post_params=form_params,            files=local_var_files,            response_type='list[WithdrawStatus]',  # noqa: E501            auth_settings=auth_settings,            async_req=local_var_params.get('async_req'),            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501            _preload_content=local_var_params.get('_preload_content', True),            _request_timeout=local_var_params.get('_request_timeout'),            collection_formats=collection_formats,        )
    def list_sub_account_balances(self, **kwargs):  # noqa: E501        """Retrieve sub account balances  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an        asynchronous HTTP request, please pass async_req=True        >>> thread = api.list_sub_account_balances(async_req=True)        >>> result = thread.get()
        :param bool async_req: execute request asynchronously        :param str sub_uid: User ID of sub-account, you can query multiple records separated by `,`. If not specified, it will return the records of all sub accounts        :param _preload_content: if False, the urllib3.HTTPResponse object will                                 be returned without reading/decoding response                                 data. Default is True.        :param _request_timeout: timeout setting for this request. If one                                 number provided, it will be total request                                 timeout. It can also be a pair (tuple) of                                 (connection, read) timeouts.        :rtype: list[gate_api.SubAccountBalance]        :return: If the method is called asynchronously,                 returns the request thread.        """
        kwargs['_return_http_data_only'] = True        return self.list_sub_account_balances_with_http_info(**kwargs)  # noqa: E501
    def list_sub_account_balances_with_http_info(self, **kwargs):  # noqa: E501        """Retrieve sub account balances  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an        asynchronous HTTP request, please pass async_req=True        >>> thread = api.list_sub_account_balances_with_http_info(async_req=True)        >>> result = thread.get()
        :param bool async_req: execute request asynchronously        :param str sub_uid: User ID of sub-account, you can query multiple records separated by `,`. If not specified, it will return the records of all sub accounts        :param _return_http_data_only: response data without head status code                                       and headers        :param _preload_content: if False, the urllib3.HTTPResponse object will                                 be returned without reading/decoding response                                 data. Default is True.        :param _request_timeout: timeout setting for this request. If one                                 number provided, it will be total request                                 timeout. It can also be a pair (tuple) of                                 (connection, read) timeouts.        :rtype: tuple(list[gate_api.SubAccountBalance], status_code(int), headers(HTTPHeaderDict))        :return: If the method is called asynchronously,                 returns the request thread.        """

        local_var_params = locals()
        all_params = ['sub_uid']        all_params.extend(['async_req', '_return_http_data_only', '_preload_content', '_request_timeout'])
        for k, v in six.iteritems(local_var_params['kwargs']):            if k not in all_params:                raise ApiTypeError("Got an unexpected keyword argument '%s'" " to method list_sub_account_balances" % k)            local_var_params[k] = v        del local_var_params['kwargs']
        collection_formats = {}
        path_params = {}
        query_params = []        if 'sub_uid' in local_var_params and local_var_params['sub_uid'] is not None:  # noqa: E501            query_params.append(('sub_uid', local_var_params['sub_uid']))  # noqa: E501
        header_params = {}
        form_params = []        local_var_files = {}
        body_params = None        # HTTP header `Accept`        header_params['Accept'] = self.api_client.select_header_accept(['application/json'])  # noqa: E501
        # Authentication setting        auth_settings = ['apiv4']  # noqa: E501
        return self.api_client.call_api(            '/wallet/sub_account_balances',            'GET',            path_params,            query_params,            header_params,            body=body_params,            post_params=form_params,            files=local_var_files,            response_type='list[SubAccountBalance]',  # noqa: E501            auth_settings=auth_settings,            async_req=local_var_params.get('async_req'),            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501            _preload_content=local_var_params.get('_preload_content', True),            _request_timeout=local_var_params.get('_request_timeout'),            collection_formats=collection_formats,        )
    def list_sub_account_margin_balances(self, **kwargs):  # noqa: E501        """Query sub accounts' margin balances  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an        asynchronous HTTP request, please pass async_req=True        >>> thread = api.list_sub_account_margin_balances(async_req=True)        >>> result = thread.get()
        :param bool async_req: execute request asynchronously        :param str sub_uid: User ID of sub-account, you can query multiple records separated by `,`. If not specified, it will return the records of all sub accounts        :param _preload_content: if False, the urllib3.HTTPResponse object will                                 be returned without reading/decoding response                                 data. Default is True.        :param _request_timeout: timeout setting for this request. If one                                 number provided, it will be total request                                 timeout. It can also be a pair (tuple) of                                 (connection, read) timeouts.        :rtype: list[gate_api.SubAccountMarginBalance]        :return: If the method is called asynchronously,                 returns the request thread.        """
        kwargs['_return_http_data_only'] = True        return self.list_sub_account_margin_balances_with_http_info(**kwargs)  # noqa: E501
    def list_sub_account_margin_balances_with_http_info(self, **kwargs):  # noqa: E501        """Query sub accounts' margin balances  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an        asynchronous HTTP request, please pass async_req=True        >>> thread = api.list_sub_account_margin_balances_with_http_info(async_req=True)        >>> result = thread.get()
        :param bool async_req: execute request asynchronously        :param str sub_uid: User ID of sub-account, you can query multiple records separated by `,`. If not specified, it will return the records of all sub accounts        :param _return_http_data_only: response data without head status code                                       and headers        :param _preload_content: if False, the urllib3.HTTPResponse object will                                 be returned without reading/decoding response                                 data. Default is True.        :param _request_timeout: timeout setting for this request. If one                                 number provided, it will be total request                                 timeout. It can also be a pair (tuple) of                                 (connection, read) timeouts.        :rtype: tuple(list[gate_api.SubAccountMarginBalance], status_code(int), headers(HTTPHeaderDict))        :return: If the method is called asynchronously,                 returns the request thread.        """

        local_var_params = locals()
        all_params = ['sub_uid']        all_params.extend(['async_req', '_return_http_data_only', '_preload_content', '_request_timeout'])
        for k, v in six.iteritems(local_var_params['kwargs']):            if k not in all_params:                raise ApiTypeError(                    "Got an unexpected keyword argument '%s'" " to method list_sub_account_margin_balances" % k                )            local_var_params[k] = v        del local_var_params['kwargs']
        collection_formats = {}
        path_params = {}
        query_params = []        if 'sub_uid' in local_var_params and local_var_params['sub_uid'] is not None:  # noqa: E501            query_params.append(('sub_uid', local_var_params['sub_uid']))  # noqa: E501
        header_params = {}
        form_params = []        local_var_files = {}
        body_params = None        # HTTP header `Accept`        header_params['Accept'] = self.api_client.select_header_accept(['application/json'])  # noqa: E501
        # Authentication setting        auth_settings = ['apiv4']  # noqa: E501
        return self.api_client.call_api(            '/wallet/sub_account_margin_balances',            'GET',            path_params,            query_params,            header_params,            body=body_params,            post_params=form_params,            files=local_var_files,            response_type='list[SubAccountMarginBalance]',  # noqa: E501            auth_settings=auth_settings,            async_req=local_var_params.get('async_req'),            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501            _preload_content=local_var_params.get('_preload_content', True),            _request_timeout=local_var_params.get('_request_timeout'),            collection_formats=collection_formats,        )
    def list_sub_account_futures_balances(self, **kwargs):  # noqa: E501        """Query sub accounts' futures account balances  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an        asynchronous HTTP request, please pass async_req=True        >>> thread = api.list_sub_account_futures_balances(async_req=True)        >>> result = thread.get()
        :param bool async_req: execute request asynchronously        :param str sub_uid: User ID of sub-account, you can query multiple records separated by `,`. If not specified, it will return the records of all sub accounts        :param str settle: Query only balances of specified settle currency        :param _preload_content: if False, the urllib3.HTTPResponse object will                                 be returned without reading/decoding response                                 data. Default is True.        :param _request_timeout: timeout setting for this request. If one                                 number provided, it will be total request                                 timeout. It can also be a pair (tuple) of                                 (connection, read) timeouts.        :rtype: list[gate_api.SubAccountFuturesBalance]        :return: If the method is called asynchronously,                 returns the request thread.        """
        kwargs['_return_http_data_only'] = True        return self.list_sub_account_futures_balances_with_http_info(**kwargs)  # noqa: E501
    def list_sub_account_futures_balances_with_http_info(self, **kwargs):  # noqa: E501        """Query sub accounts' futures account balances  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an        asynchronous HTTP request, please pass async_req=True        >>> thread = api.list_sub_account_futures_balances_with_http_info(async_req=True)        >>> result = thread.get()
        :param bool async_req: execute request asynchronously        :param str sub_uid: User ID of sub-account, you can query multiple records separated by `,`. If not specified, it will return the records of all sub accounts        :param str settle: Query only balances of specified settle currency        :param _return_http_data_only: response data without head status code                                       and headers        :param _preload_content: if False, the urllib3.HTTPResponse object will                                 be returned without reading/decoding response                                 data. Default is True.        :param _request_timeout: timeout setting for this request. If one                                 number provided, it will be total request                                 timeout. It can also be a pair (tuple) of                                 (connection, read) timeouts.        :rtype: tuple(list[gate_api.SubAccountFuturesBalance], status_code(int), headers(HTTPHeaderDict))        :return: If the method is called asynchronously,                 returns the request thread.        """

        local_var_params = locals()
        all_params = ['sub_uid', 'settle']        all_params.extend(['async_req', '_return_http_data_only', '_preload_content', '_request_timeout'])
        for k, v in six.iteritems(local_var_params['kwargs']):            if k not in all_params:                raise ApiTypeError(                    "Got an unexpected keyword argument '%s'" " to method list_sub_account_futures_balances" % k                )            local_var_params[k] = v        del local_var_params['kwargs']
        collection_formats = {}
        path_params = {}
        query_params = []        if 'sub_uid' in local_var_params and local_var_params['sub_uid'] is not None:  # noqa: E501            query_params.append(('sub_uid', local_var_params['sub_uid']))  # noqa: E501        if 'settle' in local_var_params and local_var_params['settle'] is not None:  # noqa: E501            query_params.append(('settle', local_var_params['settle']))  # noqa: E501
        header_params = {}
        form_params = []        local_var_files = {}
        body_params = None        # HTTP header `Accept`        header_params['Accept'] = self.api_client.select_header_accept(['application/json'])  # noqa: E501
        # Authentication setting        auth_settings = ['apiv4']  # noqa: E501
        return self.api_client.call_api(            '/wallet/sub_account_futures_balances',            'GET',            path_params,            query_params,            header_params,            body=body_params,            post_params=form_params,            files=local_var_files,            response_type='list[SubAccountFuturesBalance]',  # noqa: E501            auth_settings=auth_settings,            async_req=local_var_params.get('async_req'),            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501            _preload_content=local_var_params.get('_preload_content', True),            _request_timeout=local_var_params.get('_request_timeout'),            collection_formats=collection_formats,        )
    def list_sub_account_cross_margin_balances(self, **kwargs):  # noqa: E501        """Query subaccount's cross_margin account info  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an        asynchronous HTTP request, please pass async_req=True        >>> thread = api.list_sub_account_cross_margin_balances(async_req=True)        >>> result = thread.get()
        :param bool async_req: execute request asynchronously        :param str sub_uid: User ID of sub-account, you can query multiple records separated by `,`. If not specified, it will return the records of all sub accounts        :param _preload_content: if False, the urllib3.HTTPResponse object will                                 be returned without reading/decoding response                                 data. Default is True.        :param _request_timeout: timeout setting for this request. If one                                 number provided, it will be total request                                 timeout. It can also be a pair (tuple) of                                 (connection, read) timeouts.        :rtype: list[gate_api.SubAccountCrossMarginBalance]        :return: If the method is called asynchronously,                 returns the request thread.        """
        kwargs['_return_http_data_only'] = True        return self.list_sub_account_cross_margin_balances_with_http_info(**kwargs)  # noqa: E501
    def list_sub_account_cross_margin_balances_with_http_info(self, **kwargs):  # noqa: E501        """Query subaccount's cross_margin account info  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an        asynchronous HTTP request, please pass async_req=True        >>> thread = api.list_sub_account_cross_margin_balances_with_http_info(async_req=True)        >>> result = thread.get()
        :param bool async_req: execute request asynchronously        :param str sub_uid: User ID of sub-account, you can query multiple records separated by `,`. If not specified, it will return the records of all sub accounts        :param _return_http_data_only: response data without head status code                                       and headers        :param _preload_content: if False, the urllib3.HTTPResponse object will                                 be returned without reading/decoding response                                 data. Default is True.        :param _request_timeout: timeout setting for this request. If one                                 number provided, it will be total request                                 timeout. It can also be a pair (tuple) of                                 (connection, read) timeouts.        :rtype: tuple(list[gate_api.SubAccountCrossMarginBalance], status_code(int), headers(HTTPHeaderDict))        :return: If the method is called asynchronously,                 returns the request thread.        """

        local_var_params = locals()
        all_params = ['sub_uid']        all_params.extend(['async_req', '_return_http_data_only', '_preload_content', '_request_timeout'])
        for k, v in six.iteritems(local_var_params['kwargs']):            if k not in all_params:                raise ApiTypeError(                    "Got an unexpected keyword argument '%s'" " to method list_sub_account_cross_margin_balances" % k                )            local_var_params[k] = v        del local_var_params['kwargs']
        collection_formats = {}
        path_params = {}
        query_params = []        if 'sub_uid' in local_var_params and local_var_params['sub_uid'] is not None:  # noqa: E501            query_params.append(('sub_uid', local_var_params['sub_uid']))  # noqa: E501
        header_params = {}
        form_params = []        local_var_files = {}
        body_params = None        # HTTP header `Accept`        header_params['Accept'] = self.api_client.select_header_accept(['application/json'])  # noqa: E501
        # Authentication setting        auth_settings = ['apiv4']  # noqa: E501
        return self.api_client.call_api(            '/wallet/sub_account_cross_margin_balances',            'GET',            path_params,            query_params,            header_params,            body=body_params,            post_params=form_params,            files=local_var_files,            response_type='list[SubAccountCrossMarginBalance]',  # noqa: E501            auth_settings=auth_settings,            async_req=local_var_params.get('async_req'),            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501            _preload_content=local_var_params.get('_preload_content', True),            _request_timeout=local_var_params.get('_request_timeout'),            collection_formats=collection_formats,        )
    def list_saved_address(self, currency, **kwargs):  # noqa: E501        """Query saved address  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an        asynchronous HTTP request, please pass async_req=True        >>> thread = api.list_saved_address(currency, async_req=True)        >>> result = thread.get()
        :param bool async_req: execute request asynchronously        :param str currency: Currency (required)        :param str chain: Chain name        :param str limit: Maximum number returned, 100 at most        :param _preload_content: if False, the urllib3.HTTPResponse object will                                 be returned without reading/decoding response                                 data. Default is True.        :param _request_timeout: timeout setting for this request. If one                                 number provided, it will be total request                                 timeout. It can also be a pair (tuple) of                                 (connection, read) timeouts.        :rtype: list[gate_api.SavedAddress]        :return: If the method is called asynchronously,                 returns the request thread.        """
        kwargs['_return_http_data_only'] = True        return self.list_saved_address_with_http_info(currency, **kwargs)  # noqa: E501
    def list_saved_address_with_http_info(self, currency, **kwargs):  # noqa: E501        """Query saved address  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an        asynchronous HTTP request, please pass async_req=True        >>> thread = api.list_saved_address_with_http_info(currency, async_req=True)        >>> result = thread.get()
        :param bool async_req: execute request asynchronously        :param str currency: Currency (required)        :param str chain: Chain name        :param str limit: Maximum number returned, 100 at most        :param _return_http_data_only: response data without head status code                                       and headers        :param _preload_content: if False, the urllib3.HTTPResponse object will                                 be returned without reading/decoding response                                 data. Default is True.        :param _request_timeout: timeout setting for this request. If one                                 number provided, it will be total request                                 timeout. It can also be a pair (tuple) of                                 (connection, read) timeouts.        :rtype: tuple(list[gate_api.SavedAddress], status_code(int), headers(HTTPHeaderDict))        :return: If the method is called asynchronously,                 returns the request thread.        """

        local_var_params = locals()
        all_params = ['currency', 'chain', 'limit']        all_params.extend(['async_req', '_return_http_data_only', '_preload_content', '_request_timeout'])
        for k, v in six.iteritems(local_var_params['kwargs']):            if k not in all_params:                raise ApiTypeError("Got an unexpected keyword argument '%s'" " to method list_saved_address" % k)            local_var_params[k] = v        del local_var_params['kwargs']        # verify the required parameter 'currency' is set        if self.api_client.client_side_validation and (            'currency' not in local_var_params or local_var_params['currency'] is None  # noqa: E501        ):  # noqa: E501            raise ApiValueError(                "Missing the required parameter `currency` when calling `list_saved_address`"            )  # noqa: E501
        collection_formats = {}
        path_params = {}
        query_params = []        if 'currency' in local_var_params and local_var_params['currency'] is not None:  # noqa: E501            query_params.append(('currency', local_var_params['currency']))  # noqa: E501        if 'chain' in local_var_params and local_var_params['chain'] is not None:  # noqa: E501            query_params.append(('chain', local_var_params['chain']))  # noqa: E501        if 'limit' in local_var_params and local_var_params['limit'] is not None:  # noqa: E501            query_params.append(('limit', local_var_params['limit']))  # noqa: E501
        header_params = {}
        form_params = []        local_var_files = {}
        body_params = None        # HTTP header `Accept`        header_params['Accept'] = self.api_client.select_header_accept(['application/json'])  # noqa: E501
        # Authentication setting        auth_settings = ['apiv4']  # noqa: E501
        return self.api_client.call_api(            '/wallet/saved_address',            'GET',            path_params,            query_params,            header_params,            body=body_params,            post_params=form_params,            files=local_var_files,            response_type='list[SavedAddress]',  # noqa: E501            auth_settings=auth_settings,            async_req=local_var_params.get('async_req'),            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501            _preload_content=local_var_params.get('_preload_content', True),            _request_timeout=local_var_params.get('_request_timeout'),            collection_formats=collection_formats,        )
    def get_trade_fee(self, **kwargs):  # noqa: E501        """Retrieve personal trading fee  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an        asynchronous HTTP request, please pass async_req=True        >>> thread = api.get_trade_fee(async_req=True)        >>> result = thread.get()
        :param bool async_req: execute request asynchronously        :param str currency_pair: Specify a currency pair to retrieve precise fee rate  This field is optional. In most cases, the fee rate is identical among all currency pairs        :param str settle: Specify the settlement currency of the contract to get more accurate rate settings  This field is optional. Generally, the rate settings for all settlement currencies are the same.        :param _preload_content: if False, the urllib3.HTTPResponse object will                                 be returned without reading/decoding response                                 data. Default is True.        :param _request_timeout: timeout setting for this request. If one                                 number provided, it will be total request                                 timeout. It can also be a pair (tuple) of                                 (connection, read) timeouts.        :rtype: gate_api.TradeFee        :return: If the method is called asynchronously,                 returns the request thread.        """
        kwargs['_return_http_data_only'] = True        return self.get_trade_fee_with_http_info(**kwargs)  # noqa: E501
    def get_trade_fee_with_http_info(self, **kwargs):  # noqa: E501        """Retrieve personal trading fee  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an        asynchronous HTTP request, please pass async_req=True        >>> thread = api.get_trade_fee_with_http_info(async_req=True)        >>> result = thread.get()
        :param bool async_req: execute request asynchronously        :param str currency_pair: Specify a currency pair to retrieve precise fee rate  This field is optional. In most cases, the fee rate is identical among all currency pairs        :param str settle: Specify the settlement currency of the contract to get more accurate rate settings  This field is optional. Generally, the rate settings for all settlement currencies are the same.        :param _return_http_data_only: response data without head status code                                       and headers        :param _preload_content: if False, the urllib3.HTTPResponse object will                                 be returned without reading/decoding response                                 data. Default is True.        :param _request_timeout: timeout setting for this request. If one                                 number provided, it will be total request                                 timeout. It can also be a pair (tuple) of                                 (connection, read) timeouts.        :rtype: tuple(gate_api.TradeFee, status_code(int), headers(HTTPHeaderDict))        :return: If the method is called asynchronously,                 returns the request thread.        """

        local_var_params = locals()
        all_params = ['currency_pair', 'settle']        all_params.extend(['async_req', '_return_http_data_only', '_preload_content', '_request_timeout'])
        for k, v in six.iteritems(local_var_params['kwargs']):            if k not in all_params:                raise ApiTypeError("Got an unexpected keyword argument '%s'" " to method get_trade_fee" % k)            local_var_params[k] = v        del local_var_params['kwargs']
        collection_formats = {}
        path_params = {}
        query_params = []        if 'currency_pair' in local_var_params and local_var_params['currency_pair'] is not None:  # noqa: E501            query_params.append(('currency_pair', local_var_params['currency_pair']))  # noqa: E501        if 'settle' in local_var_params and local_var_params['settle'] is not None:  # noqa: E501            query_params.append(('settle', local_var_params['settle']))  # noqa: E501
        header_params = {}
        form_params = []        local_var_files = {}
        body_params = None        # HTTP header `Accept`        header_params['Accept'] = self.api_client.select_header_accept(['application/json'])  # noqa: E501
        # Authentication setting        auth_settings = ['apiv4']  # noqa: E501
        return self.api_client.call_api(            '/wallet/fee',            'GET',            path_params,            query_params,            header_params,            body=body_params,            post_params=form_params,            files=local_var_files,            response_type='TradeFee',  # noqa: E501            auth_settings=auth_settings,            async_req=local_var_params.get('async_req'),            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501            _preload_content=local_var_params.get('_preload_content', True),            _request_timeout=local_var_params.get('_request_timeout'),            collection_formats=collection_formats,        )
    def get_total_balance(self, **kwargs):  # noqa: E501        """Retrieve user's total balances  # noqa: E501

        This endpoint returns an approximate sum of exchanged amount from all currencies to input currency for each account.The exchange rate and account balance could have been cached for at most 1 minute. It is not recommended to use its result for any trading calculation.  For trading calculation, use the corresponding account query endpoint for each account type. For example:   - `GET /spot/accounts` to query spot account balance - `GET /margin/accounts` to query margin account balance - `GET /futures/{settle}/accounts` to query futures account balance  # noqa: E501        This method makes a synchronous HTTP request by default. To make an        asynchronous HTTP request, please pass async_req=True        >>> thread = api.get_total_balance(async_req=True)        >>> result = thread.get()
        :param bool async_req: execute request asynchronously        :param str currency: Currency unit used to calculate the balance amount. BTC, CNY, USD and USDT are allowed. USDT is the default.        :param _preload_content: if False, the urllib3.HTTPResponse object will                                 be returned without reading/decoding response                                 data. Default is True.        :param _request_timeout: timeout setting for this request. If one                                 number provided, it will be total request                                 timeout. It can also be a pair (tuple) of                                 (connection, read) timeouts.        :rtype: gate_api.TotalBalance        :return: If the method is called asynchronously,                 returns the request thread.        """
        kwargs['_return_http_data_only'] = True        return self.get_total_balance_with_http_info(**kwargs)  # noqa: E501
    def get_total_balance_with_http_info(self, **kwargs):  # noqa: E501        """Retrieve user's total balances  # noqa: E501

        This endpoint returns an approximate sum of exchanged amount from all currencies to input currency for each account.The exchange rate and account balance could have been cached for at most 1 minute. It is not recommended to use its result for any trading calculation.  For trading calculation, use the corresponding account query endpoint for each account type. For example:   - `GET /spot/accounts` to query spot account balance - `GET /margin/accounts` to query margin account balance - `GET /futures/{settle}/accounts` to query futures account balance  # noqa: E501        This method makes a synchronous HTTP request by default. To make an        asynchronous HTTP request, please pass async_req=True        >>> thread = api.get_total_balance_with_http_info(async_req=True)        >>> result = thread.get()
        :param bool async_req: execute request asynchronously        :param str currency: Currency unit used to calculate the balance amount. BTC, CNY, USD and USDT are allowed. USDT is the default.        :param _return_http_data_only: response data without head status code                                       and headers        :param _preload_content: if False, the urllib3.HTTPResponse object will                                 be returned without reading/decoding response                                 data. Default is True.        :param _request_timeout: timeout setting for this request. If one                                 number provided, it will be total request                                 timeout. It can also be a pair (tuple) of                                 (connection, read) timeouts.        :rtype: tuple(gate_api.TotalBalance, status_code(int), headers(HTTPHeaderDict))        :return: If the method is called asynchronously,                 returns the request thread.        """

        local_var_params = locals()
        all_params = ['currency']        all_params.extend(['async_req', '_return_http_data_only', '_preload_content', '_request_timeout'])
        for k, v in six.iteritems(local_var_params['kwargs']):            if k not in all_params:                raise ApiTypeError("Got an unexpected keyword argument '%s'" " to method get_total_balance" % k)            local_var_params[k] = v        del local_var_params['kwargs']
        collection_formats = {}
        path_params = {}
        query_params = []        if 'currency' in local_var_params and local_var_params['currency'] is not None:  # noqa: E501            query_params.append(('currency', local_var_params['currency']))  # noqa: E501
        header_params = {}
        form_params = []        local_var_files = {}
        body_params = None        # HTTP header `Accept`        header_params['Accept'] = self.api_client.select_header_accept(['application/json'])  # noqa: E501
        # Authentication setting        auth_settings = ['apiv4']  # noqa: E501
        return self.api_client.call_api(            '/wallet/total_balance',            'GET',            path_params,            query_params,            header_params,            body=body_params,            post_params=form_params,            files=local_var_files,            response_type='TotalBalance',  # noqa: E501            auth_settings=auth_settings,            async_req=local_var_params.get('async_req'),            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501            _preload_content=local_var_params.get('_preload_content', True),            _request_timeout=local_var_params.get('_request_timeout'),            collection_formats=collection_formats,        )