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
)