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)