def process_trade_history(self, start_ts, end_ts):
start_ts = int(start_ts)
end_ts = int(end_ts)
result, error_or_empty = self.rotkehlchen.process_history(
start_ts, end_ts)
response = {'result': result, 'message': error_or_empty}
return process_result(response)
def test_process_result():
d = {
'overview': {
'foo': FVal(1.0),
},
'all_events': {
'boo':
FVal(1.0),
'something': [
{
'a': 'a',
'f': FVal(1.0)
},
{
'b': 'b',
'f': FVal(2.0)
},
],
},
}
# Without process result should throw an error but with it no
with pytest.raises(TypeError):
json.dumps(d)
json.dumps(process_result(d))
def query_statistics_renderer(self):
result_dict = {'result': '', 'message': 'user does not have premium'}
if not self.rotkehlchen.premium:
return process_result(result_dict)
active = self.rotkehlchen.premium.is_active()
if not active:
return process_result(result_dict)
try:
result = self.rotkehlchen.premium.query_statistics_renderer()
result_dict['result'] = result
result_dict['message'] = ''
except RemoteError as e:
result_dict['message'] = str(e)
return process_result(result_dict)
def get_ignored_assets(self):
result = {
'ignored_assets': [
identifier for identifier in
self.rotkehlchen.data.db.get_ignored_assets()
],
}
return process_result(result)
def query_balances(self, save_data=False):
if isinstance(save_data, str) and (save_data == 'save'
or save_data == 'True'):
save_data = True
result = self.rotkehlchen.query_balances(save_data)
print(pretty_json_dumps(result))
return process_result(result)
def accounts_result(per_account, totals) -> Dict:
result = {
'result': True,
'message': '',
'per_account': per_account,
'totals': totals,
}
return process_result(result)
def query_exchange_balances(self, name):
res = {'name': name}
balances, msg = getattr(self.rotkehlchen, name).query_balances()
if balances is None:
res['error'] = msg
else:
res['balances'] = balances
return process_result(res)
def query_trade_history(self):
trades_length = len(self.trades_dict)
response = {
'result': {
'trades': self.trades_dict,
'count': trades_length
},
'error': []
}
return process_result(response)
def query_statistics_renderer(self):
result_dict = {'result': '', 'message': 'user does not have premium'}
if not self.rotkehlchen.premium:
return process_result(result_dict)
active, _ = self.rotkehlchen.premium.is_active()
if not active:
return process_result(result_dict)
success, result_or_error = self.rotkehlchen.premium.query_statistics_renderer(
)
if not success:
result_dict['message'] = result_or_error
else:
result_dict['result'] = result_or_error
result_dict['message'] = ''
return process_result(result_dict)
def query_timed_balances_data(self, asset: str, start_ts: int,
end_ts: int):
start_ts = Timestamp(start_ts)
end_ts = Timestamp(end_ts)
res = self.rotkehlchen.data.db.query_timed_balances(
from_ts=start_ts,
to_ts=end_ts,
asset=asset,
)
result = {'result': res, 'messsage': ''}
return process_result(result)
def consume_messages(self):
"""Consumes all errors and warnings from the messages aggregator"""
warnings = self.rotkehlchen.msg_aggregator.consume_warnings()
errors = self.rotkehlchen.msg_aggregator.consume_errors()
result = {
'result': {
'warnings': warnings,
'errors': errors
},
'message': ''
}
return process_result(result)
def query_timed_balances_data(self, given_asset: str, start_ts: int,
end_ts: int) -> Dict:
start_ts = Timestamp(start_ts)
end_ts = Timestamp(end_ts)
try:
asset = Asset(given_asset)
except UnknownAsset as e:
return {'result': False, 'message': str(e)}
res = self.rotkehlchen.data.db.query_timed_balances(
from_ts=start_ts,
to_ts=end_ts,
asset=asset,
)
result = {'result': res, 'message': ''}
return process_result(result)
def query_account(self):
result_data = {
'makerCommission': 15,
'takerCommission': 15,
'buyerCommission': 0,
'sellerCommission': 0,
'canTrade': True,
'canWithdraw': True,
'canDeposit': True,
'updateTime': 123456789,
}
balances = []
for asset, value in self.balances_dict.items():
balances.append({
'asset': asset,
'free': str(value),
'locked': '0.0',
})
result_data['balances'] = balances
return process_result(result_data)
def query_ledgers(self, ledger_type: str):
if ledger_type == 'all':
result_list = self.deposits_ledger
result_list.extend(self.withdrawals_ledger)
count = len(self.deposits_ledger)
count += len(self.withdrawals_ledger)
elif ledger_type == 'deposit':
count = len(self.deposits_ledger)
result_list = self.deposits_ledger
elif ledger_type == 'withdrawal':
count = len(self.withdrawals_ledger)
result_list = self.withdrawals_ledger
else:
raise ValueError(f'Invalid ledger_type {ledger_type} requested')
ledger_dict = {}
for entry in result_list:
ledger_dict[entry['refid']] = entry
result = {'ledger': ledger_dict, 'count': count}
response = {'result': result, 'error': []}
return process_result(response)
def query_periodic_data(self):
"""Will query for some client data that can change frequently"""
result = self.rotkehlchen.query_periodic_data()
return process_result(result)
def query_balances(self):
response = {'result': self.balances_dict, 'error': []}
return process_result(response)
def query_latest_asset_value_distribution(self):
res = self.rotkehlchen.data.db.get_latest_asset_value_distribution()
result = {'result': res, 'message': ''}
return process_result(result)
def query_owned_assets(self):
res = self.rotkehlchen.data.db.query_owned_assets()
result = {'result': res, 'message': ''}
return process_result(result)
def query_netvalue_data(self):
res = self.rotkehlchen.data.db.get_netvalue_data()
result = {'times': res[0], 'data': res[1]}
return process_result(result)
def get_eth_tokens(self):
result = {
'all_eth_tokens': self.rotkehlchen.data.eth_tokens,
'owned_eth_tokens': self.rotkehlchen.blockchain.eth_tokens,
}
return process_result(result)
def query_otctrades(self):
trades = self.rotkehlchen.data.get_external_trades()
result = {'result': trades, 'message': ''}
return process_result(result)
def get_settings(self):
return process_result(self.rotkehlchen.data.db.get_settings())
def get_fiat_exchange_rates(currencies):
rates = Inquirer().get_fiat_usd_exchange_rates(currencies)
res = {'exchange_rates': rates}
return process_result(res)
def query_blockchain_balances(self):
result, empty_or_error = self.rotkehlchen.blockchain.query_balances()
return process_result({'result': result, 'message': empty_or_error})
def query_fiat_balances(self):
res = self.rotkehlchen.query_fiat_balances()
return process_result(res)
def test_tuple_in_process_result():
d = {'overview': [{'foo': (FVal('0.1'), )}]}
# Process result should detect the tuple and throw
with pytest.raises(ValueError):
json.dumps(process_result(d))
def get_fiat_exchange_rates(self, currencies):
rates = self.rotkehlchen.inquirer.get_fiat_usd_exchange_rates(
currencies)
res = {'exchange_rates': rates}
return process_result(res)
