def __init__(self, api_client=None): if api_client is None: api_client = ApiClient() self.api_client = api_client def __bulk_csv(self, currency, operation, num_pages, body, **kwargs): """Get data as CSV in bulk # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.bulk_csv(currency, operation, num_pages, body, async_req=True) >>> result = thread.get() Args: currency (str): The cryptocurrency code (e.g., btc) operation (str): The operation to execute in bulk num_pages (int): Number of pages to retrieve for operations with list response body ({str: (bool, date, datetime, dict, float, int, list, str, none_type)}): Map of the operation's parameter names to (arrays of) values Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (int/float/tuple): 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. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: str If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['currency'] = \ currency kwargs['operation'] = \ operation kwargs['num_pages'] = \ num_pages kwargs['body'] = \ body return self.call_with_http_info(**kwargs) self.bulk_csv = _Endpoint(settings={ 'response_type': (str, ), 'auth': ['api_key'], 'endpoint_path': '/{currency}/bulk.csv/{operation}', 'operation_id': 'bulk_csv', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'currency', 'operation', 'num_pages', 'body', ], 'required': [ 'currency', 'operation', 'num_pages', 'body', ], 'nullable': [], 'enum': [ 'operation', ], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': { ('operation', ): { "GET_BLOCK": "get_block", "LIST_BLOCK_TXS": "list_block_txs", "GET_ADDRESS": "get_address", "LIST_ADDRESS_TXS": "list_address_txs", "LIST_TAGS_BY_ADDRESS": "list_tags_by_address", "LIST_ADDRESS_NEIGHBORS": "list_address_neighbors", "GET_ADDRESS_ENTITY": "get_address_entity", "LIST_ADDRESS_LINKS": "list_address_links", "GET_ENTITY": "get_entity", "LIST_TAGS_BY_ENTITY": "list_tags_by_entity", "LIST_ENTITY_NEIGHBORS": "list_entity_neighbors", "LIST_ENTITY_TXS": "list_entity_txs", "LIST_ENTITY_LINKS": "list_entity_links", "LIST_ENTITY_ADDRESSES": "list_entity_addresses", "GET_TX": "get_tx", "GET_TX_IO": "get_tx_io", "GET_EXCHANGE_RATES": "get_exchange_rates" }, }, 'openapi_types': { 'currency': (str, ), 'operation': (str, ), 'num_pages': (int, ), 'body': ({ str: (bool, date, datetime, dict, float, int, list, str, none_type) }, ), }, 'attribute_map': { 'currency': 'currency', 'operation': 'operation', 'num_pages': 'num_pages', }, 'location_map': { 'currency': 'path', 'operation': 'path', 'num_pages': 'query', 'body': 'body', }, 'collection_format_map': {} }, headers_map={ 'accept': ['text/csv'], 'content_type': ['application/json'] }, api_client=api_client, callable=__bulk_csv) def __bulk_json(self, currency, operation, num_pages, body, **kwargs): """Get data as JSON in bulk # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.bulk_json(currency, operation, num_pages, body, async_req=True) >>> result = thread.get() Args: currency (str): The cryptocurrency code (e.g., btc) operation (str): The operation to execute in bulk num_pages (int): Number of pages to retrieve for operations with list response body ({str: (bool, date, datetime, dict, float, int, list, str, none_type)}): Map of the operation's parameter names to (arrays of) values Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (int/float/tuple): 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. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: [{str: (bool, date, datetime, dict, float, int, list, str, none_type)}] If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['currency'] = \ currency kwargs['operation'] = \ operation kwargs['num_pages'] = \ num_pages kwargs['body'] = \ body return self.call_with_http_info(**kwargs) self.bulk_json = _Endpoint(settings={ 'response_type': ([{ str: (bool, date, datetime, dict, float, int, list, str, none_type) }], ), 'auth': ['api_key'], 'endpoint_path': '/{currency}/bulk.json/{operation}', 'operation_id': 'bulk_json', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'currency', 'operation', 'num_pages', 'body', ], 'required': [ 'currency', 'operation', 'num_pages', 'body', ], 'nullable': [], 'enum': [ 'operation', ], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': { ('operation', ): { "GET_BLOCK": "get_block", "LIST_BLOCK_TXS": "list_block_txs", "GET_ADDRESS": "get_address", "LIST_ADDRESS_TXS": "list_address_txs", "LIST_TAGS_BY_ADDRESS": "list_tags_by_address", "LIST_ADDRESS_NEIGHBORS": "list_address_neighbors", "GET_ADDRESS_ENTITY": "get_address_entity", "LIST_ADDRESS_LINKS": "list_address_links", "GET_ENTITY": "get_entity", "LIST_TAGS_BY_ENTITY": "list_tags_by_entity", "LIST_ENTITY_NEIGHBORS": "list_entity_neighbors", "LIST_ENTITY_TXS": "list_entity_txs", "LIST_ENTITY_LINKS": "list_entity_links", "LIST_ENTITY_ADDRESSES": "list_entity_addresses", "GET_TX": "get_tx", "GET_TX_IO": "get_tx_io", "GET_EXCHANGE_RATES": "get_exchange_rates" }, }, 'openapi_types': { 'currency': (str, ), 'operation': (str, ), 'num_pages': (int, ), 'body': ({ str: (bool, date, datetime, dict, float, int, list, str, none_type) }, ), }, 'attribute_map': { 'currency': 'currency', 'operation': 'operation', 'num_pages': 'num_pages', }, 'location_map': { 'currency': 'path', 'operation': 'path', 'num_pages': 'query', 'body': 'body', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': ['application/json'] }, api_client=api_client, callable=__bulk_json)
def __init__(self, api_client=None): if api_client is None: api_client = ApiClient() self.api_client = api_client def __get_tx( self, currency, tx_hash, **kwargs ): """Returns details of a specific transaction identified by its hash. # 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_tx(currency, tx_hash, async_req=True) >>> result = thread.get() Args: currency (str): The cryptocurrency code (e.g., btc) tx_hash (str): The transaction hash Keyword Args: include_io (bool): Whether to include inputs/outputs of a transaction (UTXO only). [optional] if omitted the server will use the default value of False _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (int/float/tuple): 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. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: Tx If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get( 'async_req', False ) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True ) kwargs['_preload_content'] = kwargs.get( '_preload_content', True ) kwargs['_request_timeout'] = kwargs.get( '_request_timeout', None ) kwargs['_check_input_type'] = kwargs.get( '_check_input_type', True ) kwargs['_check_return_type'] = kwargs.get( '_check_return_type', True ) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['currency'] = \ currency kwargs['tx_hash'] = \ tx_hash return self.call_with_http_info(**kwargs) self.get_tx = _Endpoint( settings={ 'response_type': (Tx,), 'auth': [ 'api_key' ], 'endpoint_path': '/{currency}/txs/{tx_hash}', 'operation_id': 'get_tx', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'currency', 'tx_hash', 'include_io', ], 'required': [ 'currency', 'tx_hash', ], 'nullable': [ ], 'enum': [ ], 'validation': [ ] }, root_map={ 'validations': { }, 'allowed_values': { }, 'openapi_types': { 'currency': (str,), 'tx_hash': (str,), 'include_io': (bool,), }, 'attribute_map': { 'currency': 'currency', 'tx_hash': 'tx_hash', 'include_io': 'include_io', }, 'location_map': { 'currency': 'path', 'tx_hash': 'path', 'include_io': 'query', }, 'collection_format_map': { } }, headers_map={ 'accept': [ 'application/json' ], 'content_type': [], }, api_client=api_client, callable=__get_tx ) def __get_tx_io( self, currency, tx_hash, io, **kwargs ): """Returns input/output values of a specific transaction identified by its hash. # 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_tx_io(currency, tx_hash, io, async_req=True) >>> result = thread.get() Args: currency (str): The cryptocurrency code (e.g., btc) tx_hash (str): The transaction hash io (str): Input or outpus values of a transaction Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (int/float/tuple): 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. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: TxValues If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get( 'async_req', False ) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True ) kwargs['_preload_content'] = kwargs.get( '_preload_content', True ) kwargs['_request_timeout'] = kwargs.get( '_request_timeout', None ) kwargs['_check_input_type'] = kwargs.get( '_check_input_type', True ) kwargs['_check_return_type'] = kwargs.get( '_check_return_type', True ) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['currency'] = \ currency kwargs['tx_hash'] = \ tx_hash kwargs['io'] = \ io return self.call_with_http_info(**kwargs) self.get_tx_io = _Endpoint( settings={ 'response_type': (TxValues,), 'auth': [ 'api_key' ], 'endpoint_path': '/{currency}/txs/{tx_hash}/{io}', 'operation_id': 'get_tx_io', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'currency', 'tx_hash', 'io', ], 'required': [ 'currency', 'tx_hash', 'io', ], 'nullable': [ ], 'enum': [ 'io', ], 'validation': [ ] }, root_map={ 'validations': { }, 'allowed_values': { ('io',): { "INPUTS": "inputs", "OUTPUTS": "outputs" }, }, 'openapi_types': { 'currency': (str,), 'tx_hash': (str,), 'io': (str,), }, 'attribute_map': { 'currency': 'currency', 'tx_hash': 'tx_hash', 'io': 'io', }, 'location_map': { 'currency': 'path', 'tx_hash': 'path', 'io': 'path', }, 'collection_format_map': { } }, headers_map={ 'accept': [ 'application/json' ], 'content_type': [], }, api_client=api_client, callable=__get_tx_io )
def __init__(self, api_client=None): if api_client is None: api_client = ApiClient() self.api_client = api_client def __list_concepts(self, taxonomy, **kwargs): """Returns the supported concepts of a taxonomy # 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_concepts(taxonomy, async_req=True) >>> result = thread.get() Args: taxonomy (str): The taxonomy Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (int/float/tuple): 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. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: [Concept] If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['taxonomy'] = \ taxonomy return self.call_with_http_info(**kwargs) self.list_concepts = _Endpoint(settings={ 'response_type': ([Concept], ), 'auth': ['api_key'], 'endpoint_path': '/tags/taxonomies/{taxonomy}/concepts', 'operation_id': 'list_concepts', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'taxonomy', ], 'required': [ 'taxonomy', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'taxonomy': (str, ), }, 'attribute_map': { 'taxonomy': 'taxonomy', }, 'location_map': { 'taxonomy': 'path', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__list_concepts) def __list_tags(self, currency, label, level, **kwargs): """Returns address or entity tags associated with a given label # 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_tags(currency, label, level, async_req=True) >>> result = thread.get() Args: currency (str): The cryptocurrency code (e.g., btc) label (str): The label of an entity level (str): Whether tags on the address or entity level are requested Keyword Args: page (str): Resumption token for retrieving the next page. [optional] pagesize (int): Number of items returned in a single page. [optional] _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (int/float/tuple): 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. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: Tags If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['currency'] = \ currency kwargs['label'] = \ label kwargs['level'] = \ level return self.call_with_http_info(**kwargs) self.list_tags = _Endpoint(settings={ 'response_type': (Tags, ), 'auth': ['api_key'], 'endpoint_path': '/{currency}/tags', 'operation_id': 'list_tags', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'currency', 'label', 'level', 'page', 'pagesize', ], 'required': [ 'currency', 'label', 'level', ], 'nullable': [], 'enum': [ 'level', ], 'validation': [ 'pagesize', ] }, root_map={ 'validations': { ('pagesize', ): { 'inclusive_minimum': 1, }, }, 'allowed_values': { ('level', ): { "ADDRESS": "address", "ENTITY": "entity" }, }, 'openapi_types': { 'currency': (str, ), 'label': (str, ), 'level': (str, ), 'page': (str, ), 'pagesize': (int, ), }, 'attribute_map': { 'currency': 'currency', 'label': 'label', 'level': 'level', 'page': 'page', 'pagesize': 'pagesize', }, 'location_map': { 'currency': 'path', 'label': 'query', 'level': 'query', 'page': 'query', 'pagesize': 'query', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__list_tags) def __list_taxonomies(self, **kwargs): """Returns the supported taxonomies # 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_taxonomies(async_req=True) >>> result = thread.get() Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (int/float/tuple): 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. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: [Taxonomy] If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') return self.call_with_http_info(**kwargs) self.list_taxonomies = _Endpoint(settings={ 'response_type': ([Taxonomy], ), 'auth': ['api_key'], 'endpoint_path': '/tags/taxonomies', 'operation_id': 'list_taxonomies', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [], 'required': [], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': {}, 'attribute_map': {}, 'location_map': {}, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__list_taxonomies)
def __init__(self, api_client=None): if api_client is None: api_client = ApiClient() self.api_client = api_client def __get_statistics(self, **kwargs): """Get statistics of supported currencies # 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_statistics(async_req=True) >>> result = thread.get() Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (int/float/tuple): 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. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: Stats If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') return self.call_with_http_info(**kwargs) self.get_statistics = _Endpoint(settings={ 'response_type': (Stats, ), 'auth': [], 'endpoint_path': '/stats', 'operation_id': 'get_statistics', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [], 'required': [], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': {}, 'attribute_map': {}, 'location_map': {}, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__get_statistics) def __search(self, q, **kwargs): """Returns matching addresses, transactions and labels # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.search(q, async_req=True) >>> result = thread.get() Args: q (str): It can be (the beginning of) an address, a transaction or a label Keyword Args: currency (str): The cryptocurrency (e.g., btc). [optional] limit (int): Maximum number of search results. [optional] if omitted the server will use the default value of 10 _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (int/float/tuple): 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. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: SearchResult If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['q'] = \ q return self.call_with_http_info(**kwargs) self.search = _Endpoint( settings={ 'response_type': (SearchResult, ), 'auth': ['api_key'], 'endpoint_path': '/search', 'operation_id': 'search', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'q', 'currency', 'limit', ], 'required': [ 'q', ], 'nullable': [], 'enum': [], 'validation': [ 'q', 'limit', ] }, root_map={ 'validations': { ('q', ): { 'min_length': 3, 'regex': { 'pattern': r'^[\w ]+$', # noqa: E501 }, }, ('limit', ): { 'inclusive_maximum': 100, }, }, 'allowed_values': {}, 'openapi_types': { 'q': (str, ), 'currency': (str, ), 'limit': (int, ), }, 'attribute_map': { 'q': 'q', 'currency': 'currency', 'limit': 'limit', }, 'location_map': { 'q': 'query', 'currency': 'query', 'limit': 'query', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__search)
def __init__(self, api_client=None): if api_client is None: api_client = ApiClient() self.api_client = api_client def __get_entity(self, currency, entity, **kwargs): """Get an entity, optionally with tags # 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_entity(currency, entity, async_req=True) >>> result = thread.get() Args: currency (str): The cryptocurrency code (e.g., btc) entity (int): The entity ID Keyword Args: include_tags (bool): Whether to include the first page of tags. Use the respective /tags endpoint to retrieve more if needed.. [optional] if omitted the server will use the default value of False _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (int/float/tuple): 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. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: Entity If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['currency'] = \ currency kwargs['entity'] = \ entity return self.call_with_http_info(**kwargs) self.get_entity = _Endpoint(settings={ 'response_type': (Entity, ), 'auth': ['api_key'], 'endpoint_path': '/{currency}/entities/{entity}', 'operation_id': 'get_entity', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'currency', 'entity', 'include_tags', ], 'required': [ 'currency', 'entity', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'currency': (str, ), 'entity': (int, ), 'include_tags': (bool, ), }, 'attribute_map': { 'currency': 'currency', 'entity': 'entity', 'include_tags': 'include_tags', }, 'location_map': { 'currency': 'path', 'entity': 'path', 'include_tags': 'query', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__get_entity) def __list_entity_addresses(self, currency, entity, **kwargs): """Get an entity's addresses # 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_entity_addresses(currency, entity, async_req=True) >>> result = thread.get() Args: currency (str): The cryptocurrency code (e.g., btc) entity (int): The entity ID Keyword Args: page (str): Resumption token for retrieving the next page. [optional] pagesize (int): Number of items returned in a single page. [optional] _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (int/float/tuple): 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. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: EntityAddresses If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['currency'] = \ currency kwargs['entity'] = \ entity return self.call_with_http_info(**kwargs) self.list_entity_addresses = _Endpoint( settings={ 'response_type': (EntityAddresses, ), 'auth': ['api_key'], 'endpoint_path': '/{currency}/entities/{entity}/addresses', 'operation_id': 'list_entity_addresses', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'currency', 'entity', 'page', 'pagesize', ], 'required': [ 'currency', 'entity', ], 'nullable': [], 'enum': [], 'validation': [ 'pagesize', ] }, root_map={ 'validations': { ('pagesize', ): { 'inclusive_minimum': 1, }, }, 'allowed_values': {}, 'openapi_types': { 'currency': (str, ), 'entity': (int, ), 'page': (str, ), 'pagesize': (int, ), }, 'attribute_map': { 'currency': 'currency', 'entity': 'entity', 'page': 'page', 'pagesize': 'pagesize', }, 'location_map': { 'currency': 'path', 'entity': 'path', 'page': 'query', 'pagesize': 'query', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__list_entity_addresses) def __list_entity_links(self, currency, entity, neighbor, **kwargs): """Get transactions between two entities # 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_entity_links(currency, entity, neighbor, async_req=True) >>> result = thread.get() Args: currency (str): The cryptocurrency code (e.g., btc) entity (int): The entity ID neighbor (int): Neighbor entity Keyword Args: page (str): Resumption token for retrieving the next page. [optional] pagesize (int): Number of items returned in a single page. [optional] _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (int/float/tuple): 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. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: Links If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['currency'] = \ currency kwargs['entity'] = \ entity kwargs['neighbor'] = \ neighbor return self.call_with_http_info(**kwargs) self.list_entity_links = _Endpoint(settings={ 'response_type': (Links, ), 'auth': ['api_key'], 'endpoint_path': '/{currency}/entities/{entity}/links', 'operation_id': 'list_entity_links', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'currency', 'entity', 'neighbor', 'page', 'pagesize', ], 'required': [ 'currency', 'entity', 'neighbor', ], 'nullable': [], 'enum': [], 'validation': [ 'pagesize', ] }, root_map={ 'validations': { ('pagesize', ): { 'inclusive_minimum': 1, }, }, 'allowed_values': {}, 'openapi_types': { 'currency': (str, ), 'entity': (int, ), 'neighbor': (int, ), 'page': (str, ), 'pagesize': (int, ), }, 'attribute_map': { 'currency': 'currency', 'entity': 'entity', 'neighbor': 'neighbor', 'page': 'page', 'pagesize': 'pagesize', }, 'location_map': { 'currency': 'path', 'entity': 'path', 'neighbor': 'query', 'page': 'query', 'pagesize': 'query', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__list_entity_links) def __list_entity_neighbors(self, currency, entity, direction, **kwargs): """Get an entity's neighbors in the entity graph # 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_entity_neighbors(currency, entity, direction, async_req=True) >>> result = thread.get() Args: currency (str): The cryptocurrency code (e.g., btc) entity (int): The entity ID direction (str): Incoming or outgoing neighbors Keyword Args: only_ids (OnlyEntityIds): Restrict result to given set of comma separated IDs. [optional] include_labels (bool): Whether to include labels of first page of tags. [optional] if omitted the server will use the default value of False page (str): Resumption token for retrieving the next page. [optional] pagesize (int): Number of items returned in a single page. [optional] _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (int/float/tuple): 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. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: Neighbors If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['currency'] = \ currency kwargs['entity'] = \ entity kwargs['direction'] = \ direction return self.call_with_http_info(**kwargs) self.list_entity_neighbors = _Endpoint( settings={ 'response_type': (Neighbors, ), 'auth': ['api_key'], 'endpoint_path': '/{currency}/entities/{entity}/neighbors', 'operation_id': 'list_entity_neighbors', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'currency', 'entity', 'direction', 'only_ids', 'include_labels', 'page', 'pagesize', ], 'required': [ 'currency', 'entity', 'direction', ], 'nullable': [], 'enum': [ 'direction', ], 'validation': [ 'pagesize', ] }, root_map={ 'validations': { ('pagesize', ): { 'inclusive_minimum': 1, }, }, 'allowed_values': { ('direction', ): { "IN": "in", "OUT": "out" }, }, 'openapi_types': { 'currency': (str, ), 'entity': (int, ), 'direction': (str, ), 'only_ids': (OnlyEntityIds, ), 'include_labels': (bool, ), 'page': (str, ), 'pagesize': (int, ), }, 'attribute_map': { 'currency': 'currency', 'entity': 'entity', 'direction': 'direction', 'only_ids': 'only_ids', 'include_labels': 'include_labels', 'page': 'page', 'pagesize': 'pagesize', }, 'location_map': { 'currency': 'path', 'entity': 'path', 'direction': 'query', 'only_ids': 'query', 'include_labels': 'query', 'page': 'query', 'pagesize': 'query', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__list_entity_neighbors) def __list_entity_txs(self, currency, entity, **kwargs): """Get all transactions an entity has been involved in # 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_entity_txs(currency, entity, async_req=True) >>> result = thread.get() Args: currency (str): The cryptocurrency code (e.g., btc) entity (int): The entity ID Keyword Args: page (str): Resumption token for retrieving the next page. [optional] pagesize (int): Number of items returned in a single page. [optional] _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (int/float/tuple): 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. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: AddressTxs If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['currency'] = \ currency kwargs['entity'] = \ entity return self.call_with_http_info(**kwargs) self.list_entity_txs = _Endpoint(settings={ 'response_type': (AddressTxs, ), 'auth': ['api_key'], 'endpoint_path': '/{currency}/entities/{entity}/txs', 'operation_id': 'list_entity_txs', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'currency', 'entity', 'page', 'pagesize', ], 'required': [ 'currency', 'entity', ], 'nullable': [], 'enum': [], 'validation': [ 'pagesize', ] }, root_map={ 'validations': { ('pagesize', ): { 'inclusive_minimum': 1, }, }, 'allowed_values': {}, 'openapi_types': { 'currency': (str, ), 'entity': (int, ), 'page': (str, ), 'pagesize': (int, ), }, 'attribute_map': { 'currency': 'currency', 'entity': 'entity', 'page': 'page', 'pagesize': 'pagesize', }, 'location_map': { 'currency': 'path', 'entity': 'path', 'page': 'query', 'pagesize': 'query', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__list_entity_txs) def __list_tags_by_entity(self, currency, entity, level, **kwargs): """Get tags for a given entity for the given level # 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_tags_by_entity(currency, entity, level, async_req=True) >>> result = thread.get() Args: currency (str): The cryptocurrency code (e.g., btc) entity (int): The entity ID level (str): Whether tags on the address or entity level are requested Keyword Args: page (str): Resumption token for retrieving the next page. [optional] pagesize (int): Number of items returned in a single page. [optional] _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (int/float/tuple): 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. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: Tags If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['currency'] = \ currency kwargs['entity'] = \ entity kwargs['level'] = \ level return self.call_with_http_info(**kwargs) self.list_tags_by_entity = _Endpoint(settings={ 'response_type': (Tags, ), 'auth': ['api_key'], 'endpoint_path': '/{currency}/entities/{entity}/tags', 'operation_id': 'list_tags_by_entity', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'currency', 'entity', 'level', 'page', 'pagesize', ], 'required': [ 'currency', 'entity', 'level', ], 'nullable': [], 'enum': [ 'level', ], 'validation': [ 'pagesize', ] }, root_map={ 'validations': { ('pagesize', ): { 'inclusive_minimum': 1, }, }, 'allowed_values': { ('level', ): { "ADDRESS": "address", "ENTITY": "entity" }, }, 'openapi_types': { 'currency': (str, ), 'entity': (int, ), 'level': (str, ), 'page': (str, ), 'pagesize': (int, ), }, 'attribute_map': { 'currency': 'currency', 'entity': 'entity', 'level': 'level', 'page': 'page', 'pagesize': 'pagesize', }, 'location_map': { 'currency': 'path', 'entity': 'path', 'level': 'query', 'page': 'query', 'pagesize': 'query', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__list_tags_by_entity) def __search_entity_neighbors(self, currency, entity, direction, key, value, depth, **kwargs): """Search deeply for matching neighbors # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.search_entity_neighbors(currency, entity, direction, key, value, depth, async_req=True) >>> result = thread.get() Args: currency (str): The cryptocurrency code (e.g., btc) entity (int): The entity ID direction (str): Incoming or outgoing neighbors key (str): Match neighbors against one and only one of these properties: - the category the entity belongs to - addresses the entity contains - entity ids - total_received: amount the entity received in total - balance: amount the entity holds finally value ([str]): If key is - category: comma separated list of category names - addresses: comma separated list of address IDs - entities: comma separated list of entity IDs - total_received/balance: comma separated tuple of (currency, min, max) where currency is 'value' for the cryptocurrency value or an ISO currency code depth (int): How many hops should the transaction graph be searched Keyword Args: breadth (int): How many siblings of each neighbor should be tried. [optional] if omitted the server will use the default value of 16 skip_num_addresses (int): Skip entities containing more addresses. [optional] _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (int/float/tuple): 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. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: SearchResultLevel1 If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['currency'] = \ currency kwargs['entity'] = \ entity kwargs['direction'] = \ direction kwargs['key'] = \ key kwargs['value'] = \ value kwargs['depth'] = \ depth return self.call_with_http_info(**kwargs) self.search_entity_neighbors = _Endpoint( settings={ 'response_type': (SearchResultLevel1, ), 'auth': ['api_key'], 'endpoint_path': '/{currency}/entities/{entity}/search', 'operation_id': 'search_entity_neighbors', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'currency', 'entity', 'direction', 'key', 'value', 'depth', 'breadth', 'skip_num_addresses', ], 'required': [ 'currency', 'entity', 'direction', 'key', 'value', 'depth', ], 'nullable': [], 'enum': [ 'direction', 'key', ], 'validation': [ 'depth', ] }, root_map={ 'validations': { ('depth', ): { 'inclusive_maximum': 7, }, }, 'allowed_values': { ('direction', ): { "IN": "in", "OUT": "out" }, ('key', ): { "CATEGORY": "category", "ADDRESSES": "addresses", "ENTITIES": "entities", "TOTAL_RECEIVED": "total_received", "BALANCE": "balance" }, }, 'openapi_types': { 'currency': (str, ), 'entity': (int, ), 'direction': (str, ), 'key': (str, ), 'value': ([str], ), 'depth': (int, ), 'breadth': (int, ), 'skip_num_addresses': (int, ), }, 'attribute_map': { 'currency': 'currency', 'entity': 'entity', 'direction': 'direction', 'key': 'key', 'value': 'value', 'depth': 'depth', 'breadth': 'breadth', 'skip_num_addresses': 'skip_num_addresses', }, 'location_map': { 'currency': 'path', 'entity': 'path', 'direction': 'query', 'key': 'query', 'value': 'query', 'depth': 'query', 'breadth': 'query', 'skip_num_addresses': 'query', }, 'collection_format_map': { 'value': 'multi', } }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__search_entity_neighbors)
def __init__(self, api_client=None): if api_client is None: api_client = ApiClient() self.api_client = api_client def __get_address(self, currency, address, **kwargs): """Get an address, optionally with tags # 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_address(currency, address, async_req=True) >>> result = thread.get() Args: currency (str): The cryptocurrency code (e.g., btc) address (str): The cryptocurrency address Keyword Args: include_tags (bool): Whether to include the first page of tags. Use the respective /tags endpoint to retrieve more if needed.. [optional] if omitted the server will use the default value of False _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (int/float/tuple): 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. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: Address If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['currency'] = \ currency kwargs['address'] = \ address return self.call_with_http_info(**kwargs) self.get_address = _Endpoint(settings={ 'response_type': (Address, ), 'auth': ['api_key'], 'endpoint_path': '/{currency}/addresses/{address}', 'operation_id': 'get_address', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'currency', 'address', 'include_tags', ], 'required': [ 'currency', 'address', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'currency': (str, ), 'address': (str, ), 'include_tags': (bool, ), }, 'attribute_map': { 'currency': 'currency', 'address': 'address', 'include_tags': 'include_tags', }, 'location_map': { 'currency': 'path', 'address': 'path', 'include_tags': 'query', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__get_address) def __get_address_entity(self, currency, address, **kwargs): """Get the entity of an 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_address_entity(currency, address, async_req=True) >>> result = thread.get() Args: currency (str): The cryptocurrency code (e.g., btc) address (str): The cryptocurrency address Keyword Args: include_tags (bool): Whether to include the first page of tags. Use the respective /tags endpoint to retrieve more if needed.. [optional] if omitted the server will use the default value of False _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (int/float/tuple): 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. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: Entity If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['currency'] = \ currency kwargs['address'] = \ address return self.call_with_http_info(**kwargs) self.get_address_entity = _Endpoint(settings={ 'response_type': (Entity, ), 'auth': ['api_key'], 'endpoint_path': '/{currency}/addresses/{address}/entity', 'operation_id': 'get_address_entity', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'currency', 'address', 'include_tags', ], 'required': [ 'currency', 'address', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'currency': (str, ), 'address': (str, ), 'include_tags': (bool, ), }, 'attribute_map': { 'currency': 'currency', 'address': 'address', 'include_tags': 'include_tags', }, 'location_map': { 'currency': 'path', 'address': 'path', 'include_tags': 'query', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__get_address_entity) def __list_address_links(self, currency, address, neighbor, **kwargs): """Get outgoing transactions between two addresses # 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_address_links(currency, address, neighbor, async_req=True) >>> result = thread.get() Args: currency (str): The cryptocurrency code (e.g., btc) address (str): The cryptocurrency address neighbor (str): Neighbor address Keyword Args: page (str): Resumption token for retrieving the next page. [optional] pagesize (int): Number of items returned in a single page. [optional] _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (int/float/tuple): 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. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: Links If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['currency'] = \ currency kwargs['address'] = \ address kwargs['neighbor'] = \ neighbor return self.call_with_http_info(**kwargs) self.list_address_links = _Endpoint(settings={ 'response_type': (Links, ), 'auth': ['api_key'], 'endpoint_path': '/{currency}/addresses/{address}/links', 'operation_id': 'list_address_links', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'currency', 'address', 'neighbor', 'page', 'pagesize', ], 'required': [ 'currency', 'address', 'neighbor', ], 'nullable': [], 'enum': [], 'validation': [ 'pagesize', ] }, root_map={ 'validations': { ('pagesize', ): { 'inclusive_minimum': 1, }, }, 'allowed_values': {}, 'openapi_types': { 'currency': (str, ), 'address': (str, ), 'neighbor': (str, ), 'page': (str, ), 'pagesize': (int, ), }, 'attribute_map': { 'currency': 'currency', 'address': 'address', 'neighbor': 'neighbor', 'page': 'page', 'pagesize': 'pagesize', }, 'location_map': { 'currency': 'path', 'address': 'path', 'neighbor': 'query', 'page': 'query', 'pagesize': 'query', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__list_address_links) def __list_address_neighbors(self, currency, address, direction, **kwargs): """Get an addresses' neighbors in the address graph # 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_address_neighbors(currency, address, direction, async_req=True) >>> result = thread.get() Args: currency (str): The cryptocurrency code (e.g., btc) address (str): The cryptocurrency address direction (str): Incoming or outgoing neighbors Keyword Args: include_labels (bool): Whether to include labels of first page of tags. [optional] if omitted the server will use the default value of False page (str): Resumption token for retrieving the next page. [optional] pagesize (int): Number of items returned in a single page. [optional] _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (int/float/tuple): 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. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: Neighbors If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['currency'] = \ currency kwargs['address'] = \ address kwargs['direction'] = \ direction return self.call_with_http_info(**kwargs) self.list_address_neighbors = _Endpoint( settings={ 'response_type': (Neighbors, ), 'auth': ['api_key'], 'endpoint_path': '/{currency}/addresses/{address}/neighbors', 'operation_id': 'list_address_neighbors', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'currency', 'address', 'direction', 'include_labels', 'page', 'pagesize', ], 'required': [ 'currency', 'address', 'direction', ], 'nullable': [], 'enum': [ 'direction', ], 'validation': [ 'pagesize', ] }, root_map={ 'validations': { ('pagesize', ): { 'inclusive_minimum': 1, }, }, 'allowed_values': { ('direction', ): { "IN": "in", "OUT": "out" }, }, 'openapi_types': { 'currency': (str, ), 'address': (str, ), 'direction': (str, ), 'include_labels': (bool, ), 'page': (str, ), 'pagesize': (int, ), }, 'attribute_map': { 'currency': 'currency', 'address': 'address', 'direction': 'direction', 'include_labels': 'include_labels', 'page': 'page', 'pagesize': 'pagesize', }, 'location_map': { 'currency': 'path', 'address': 'path', 'direction': 'query', 'include_labels': 'query', 'page': 'query', 'pagesize': 'query', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__list_address_neighbors) def __list_address_txs(self, currency, address, **kwargs): """Get all transactions an address has been involved in # 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_address_txs(currency, address, async_req=True) >>> result = thread.get() Args: currency (str): The cryptocurrency code (e.g., btc) address (str): The cryptocurrency address Keyword Args: page (str): Resumption token for retrieving the next page. [optional] pagesize (int): Number of items returned in a single page. [optional] _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (int/float/tuple): 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. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: AddressTxs If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['currency'] = \ currency kwargs['address'] = \ address return self.call_with_http_info(**kwargs) self.list_address_txs = _Endpoint(settings={ 'response_type': (AddressTxs, ), 'auth': ['api_key'], 'endpoint_path': '/{currency}/addresses/{address}/txs', 'operation_id': 'list_address_txs', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'currency', 'address', 'page', 'pagesize', ], 'required': [ 'currency', 'address', ], 'nullable': [], 'enum': [], 'validation': [ 'pagesize', ] }, root_map={ 'validations': { ('pagesize', ): { 'inclusive_minimum': 1, }, }, 'allowed_values': {}, 'openapi_types': { 'currency': (str, ), 'address': (str, ), 'page': (str, ), 'pagesize': (int, ), }, 'attribute_map': { 'currency': 'currency', 'address': 'address', 'page': 'page', 'pagesize': 'pagesize', }, 'location_map': { 'currency': 'path', 'address': 'path', 'page': 'query', 'pagesize': 'query', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__list_address_txs) def __list_tags_by_address(self, currency, address, **kwargs): """Get attribution tags for a given 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_tags_by_address(currency, address, async_req=True) >>> result = thread.get() Args: currency (str): The cryptocurrency code (e.g., btc) address (str): The cryptocurrency address Keyword Args: page (str): Resumption token for retrieving the next page. [optional] pagesize (int): Number of items returned in a single page. [optional] _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (int/float/tuple): 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. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: AddressTags If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['currency'] = \ currency kwargs['address'] = \ address return self.call_with_http_info(**kwargs) self.list_tags_by_address = _Endpoint(settings={ 'response_type': (AddressTags, ), 'auth': ['api_key'], 'endpoint_path': '/{currency}/addresses/{address}/tags', 'operation_id': 'list_tags_by_address', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'currency', 'address', 'page', 'pagesize', ], 'required': [ 'currency', 'address', ], 'nullable': [], 'enum': [], 'validation': [ 'pagesize', ] }, root_map={ 'validations': { ('pagesize', ): { 'inclusive_minimum': 1, }, }, 'allowed_values': {}, 'openapi_types': { 'currency': (str, ), 'address': (str, ), 'page': (str, ), 'pagesize': (int, ), }, 'attribute_map': { 'currency': 'currency', 'address': 'address', 'page': 'page', 'pagesize': 'pagesize', }, 'location_map': { 'currency': 'path', 'address': 'path', 'page': 'query', 'pagesize': 'query', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__list_tags_by_address)
def __init__(self, api_client=None): if api_client is None: api_client = ApiClient() self.api_client = api_client def __get_block( self, currency, height, **kwargs ): """Get a block by its height # 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_block(currency, height, async_req=True) >>> result = thread.get() Args: currency (str): The cryptocurrency code (e.g., btc) height (Height): The block height Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (int/float/tuple): 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. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: Block If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get( 'async_req', False ) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True ) kwargs['_preload_content'] = kwargs.get( '_preload_content', True ) kwargs['_request_timeout'] = kwargs.get( '_request_timeout', None ) kwargs['_check_input_type'] = kwargs.get( '_check_input_type', True ) kwargs['_check_return_type'] = kwargs.get( '_check_return_type', True ) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['currency'] = \ currency kwargs['height'] = \ height return self.call_with_http_info(**kwargs) self.get_block = _Endpoint( settings={ 'response_type': (Block,), 'auth': [ 'api_key' ], 'endpoint_path': '/{currency}/blocks/{height}', 'operation_id': 'get_block', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'currency', 'height', ], 'required': [ 'currency', 'height', ], 'nullable': [ ], 'enum': [ ], 'validation': [ ] }, root_map={ 'validations': { }, 'allowed_values': { }, 'openapi_types': { 'currency': (str,), 'height': (Height,), }, 'attribute_map': { 'currency': 'currency', 'height': 'height', }, 'location_map': { 'currency': 'path', 'height': 'path', }, 'collection_format_map': { } }, headers_map={ 'accept': [ 'application/json' ], 'content_type': [], }, api_client=api_client, callable=__get_block ) def __list_block_txs( self, currency, height, **kwargs ): """Get block transactions # 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_block_txs(currency, height, async_req=True) >>> result = thread.get() Args: currency (str): The cryptocurrency code (e.g., btc) height (Height): The block height Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (int/float/tuple): 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. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: [Tx] If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get( 'async_req', False ) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True ) kwargs['_preload_content'] = kwargs.get( '_preload_content', True ) kwargs['_request_timeout'] = kwargs.get( '_request_timeout', None ) kwargs['_check_input_type'] = kwargs.get( '_check_input_type', True ) kwargs['_check_return_type'] = kwargs.get( '_check_return_type', True ) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['currency'] = \ currency kwargs['height'] = \ height return self.call_with_http_info(**kwargs) self.list_block_txs = _Endpoint( settings={ 'response_type': ([Tx],), 'auth': [ 'api_key' ], 'endpoint_path': '/{currency}/blocks/{height}/txs', 'operation_id': 'list_block_txs', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'currency', 'height', ], 'required': [ 'currency', 'height', ], 'nullable': [ ], 'enum': [ ], 'validation': [ ] }, root_map={ 'validations': { }, 'allowed_values': { }, 'openapi_types': { 'currency': (str,), 'height': (Height,), }, 'attribute_map': { 'currency': 'currency', 'height': 'height', }, 'location_map': { 'currency': 'path', 'height': 'path', }, 'collection_format_map': { } }, headers_map={ 'accept': [ 'application/json' ], 'content_type': [], }, api_client=api_client, callable=__list_block_txs )