mmgen-node-tools/mmgen_node_tools/Ticker.py

#!/usr/bin/env python3
#
# mmgen = Multi-Mode GENerator, a command-line cryptocurrency wallet
# Copyright (C)2013-2022 The MMGen Project <mmgen@tuta.io>
# Licensed under the GNU General Public License, Version 3:
#   https://www.gnu.org/licenses
# Public project repositories:
#   https://github.com/mmgen/mmgen https://github.com/mmgen/mmgen-node-tools
#   https://gitlab.com/mmgen/mmgen https://gitlab.com/mmgen/mmgen-node-tools

"""
mmgen_node_tools.Ticker: Display price information for cryptocurrency and other assets
"""

api_host = 'api.coinpaprika.com'
api_url  = f'https://{api_host}/v1/ticker'
ratelimit = 240
btc_ratelimit = 10

# We use deprecated coinpaprika ‘ticker’ API for now because it returns ~45% less data.
# Old ‘ticker’ API  (/v1/ticker):  data['BTC']['price_usd']
# New ‘tickers’ API (/v1/tickers): data['BTC']['quotes']['USD']['price']

# Possible alternatives:
# - https://min-api.cryptocompare.com/data/pricemultifull?fsyms=BTC,LTC&tsyms=USD,EUR

import sys,os,time,json,yaml
from subprocess import run,PIPE,CalledProcessError
from decimal import Decimal
from collections import namedtuple
from mmgen.opts import opt
from mmgen.globalvars import g
from mmgen.color import *
from mmgen.util import die,fmt_list,msg,msg_r,Msg,do_pager,suf,fmt

homedir = os.getenv('HOME')
cachedir = os.path.join(homedir,'.cache','mmgen-node-tools')
cfg_fn = 'ticker-cfg.yaml'
portfolio_fn = 'ticker-portfolio.yaml'

def assets_list_gen(cfg_in):
	for k,v in cfg_in.cfg['assets'].items():
		yield('')
		yield(k.upper())
		for e in v:
			yield('  {:4s} {}'.format(*e.split('-',1)))

def gen_data(data):
	"""
	Filter the raw data and return it as a dict keyed by the IDs of the assets
	we want to display.

	Add dummy entry for USD and entry for user-specified asset, if any.

	Since symbols in source data are not guaranteed to be unique (e.g. XAG), we
	must search the data twice: first for unique IDs, then for symbols while
	checking for duplicates.
	"""

	def dup_sym_errmsg(dup_sym):
		return (
			f'The symbol {dup_sym!r} is shared by the following assets:\n' +
			'\n  ' + '\n  '.join(d['id'] for d in data if d['symbol'] == dup_sym) +
			'\n\nPlease specify the asset by one of the full IDs listed above\n' +
			f'instead of {dup_sym!r}'
		)

	def check_assets_found(wants,found,keys=['symbol','id']):
		error = False
		for k in keys:
			missing = wants[k] - found[k]
			if missing:
				msg(
					('The following IDs were not found in source data:\n{}' if k == 'id' else
					'The following symbols could not be resolved:\n{}').format(
						fmt_list(missing,fmt='col',indent='  ')
				))
				error = True
		if error:
			die(1,'Missing data, exiting')

	rows_want = {
		'id':     {r.id for r in cfg.rows if getattr(r,'id',None)} - {'usd-us-dollar'},
		'symbol': {r.symbol for r in cfg.rows if isinstance(r,tuple) and r.id is None} - {'USD'},
	}
	usr_assets = cfg.usr_rows + cfg.usr_columns + tuple(c for c in (cfg.query or ()) if c)
	usr_wants = {
		'id': (
			{a.id for a in usr_assets if a.id} -
			{a.id for a in usr_assets if a.amount and a.id} - {'usd-us-dollar'} )
		,
		'symbol': (
			{a.symbol for a in usr_assets if not a.id} -
			{a.symbol for a in usr_assets if a.amount} - {'USD'} ),
	}

	found = { 'id': set(), 'symbol': set() }

	for k in ['id','symbol']:
		wants = rows_want[k] | usr_wants[k]
		if wants:
			for d in data:
				if d[k] in wants:
					if d[k] in found[k]:
						die(1,dup_sym_errmsg(d[k]))
					yield (d['id'],d)
					found[k].add(d[k])
					if k == 'id' and len(found[k]) == len(wants):
						break

	for d in data:
		if d['id'] == 'btc-bitcoin':
			btcusd = Decimal(d['price_usd'])
			break

	for asset in (cfg.usr_rows + cfg.usr_columns):
		if asset.amount:
			"""
			User-supplied rate overrides rate from source data.
			"""
			_id = asset.id or f'{asset.symbol}-user-asset-{asset.symbol}'.lower()
			yield ( _id, {
				'symbol': asset.symbol,
				'id': _id,
				'price_usd': str(Decimal(1/asset.amount)),
				'price_btc': str(Decimal(1/asset.amount/btcusd)),
				'last_updated': int(now),
			})

	yield ('usd-us-dollar', {
		'symbol': 'USD',
		'id': 'usd-us-dollar',
		'price_usd': '1.0',
		'price_btc': str(Decimal(1/btcusd)),
		'last_updated': int(now),
	})

	check_assets_found(usr_wants,found)

def get_src_data(curl_cmd):

	tor_captcha_msg = f"""
		If you’re using Tor, the API request may have failed due to Captcha protection.
		A workaround for this issue is to retrieve the JSON data with a browser from
		the following URL:

		    {api_url}

		and save it to:

		    ‘{cfg.cachedir}/ticker.json’

		Then invoke the program with --cached-data and without --btc
	"""

	def rate_limit_errmsg(timeout,elapsed):
		return (
			f'Rate limit exceeded!  Retry in {timeout-elapsed} seconds' +
			('' if cfg.btc_only else ', or use --cached-data or --btc')
		)

	if not os.path.exists(cachedir):
		os.makedirs(cachedir)

	if cfg.btc_only:
		fn = os.path.join(cfg.cachedir,'ticker-btc.json')
		timeout = 5 if g.test_suite else btc_ratelimit
	else:
		fn = os.path.join(cfg.cachedir,'ticker.json')
		timeout = 5 if g.test_suite else ratelimit

	fn_rel = os.path.relpath(fn,start=homedir)

	if not os.path.exists(fn):
		open(fn,'w').write('{}')

	if opt.cached_data:
		json_text = open(fn).read()
	else:
		elapsed = int(time.time() - os.stat(fn).st_mtime)
		if elapsed >= timeout:
			msg_r(f'Fetching data from {api_host}...')
			try:
				cp = run(curl_cmd,check=True,stdout=PIPE)
			except CalledProcessError as e:
				msg('')
				from .Misc import curl_exit_codes
				msg(red(curl_exit_codes[e.returncode]))
				msg(red('Command line:\n  {}'.format( ' '.join((repr(i) if ' ' in i else i) for i in e.cmd) )))
				from mmgen.exception import MMGenCalledProcessError
				raise MMGenCalledProcessError(f'Subprocess returned non-zero exit status {e.returncode}')
			json_text = cp.stdout.decode()
			msg('done')
		else:
			die(1,rate_limit_errmsg(timeout,elapsed))

	try:
		data = json.loads(json_text)
	except:
		msg(json_text[:1024] + '...')
		msg(orange(fmt(tor_captcha_msg,strip_char='\t')))
		die(2,'Retrieved data is not valid JSON, exiting')

	if not data:
		if opt.cached_data:
			die(1,'No cached data!  Run command without --cached-data option to retrieve data from remote host')
		else:
			die(2,'Remote host returned no data!')
	elif 'error' in data:
		die(1,data['error'])

	if opt.cached_data:
		msg(f'Using cached data from ~/{fn_rel}')
	else:
		open(fn,'w').write(json_text)
		msg(f'JSON data cached to ~/{fn_rel}')

	return data

def main(cfg_parm,cfg_in_parm):

	def update_sample_file(usr_cfg_file):
		src_data = files('mmgen_node_tools').joinpath('data',os.path.basename(usr_cfg_file)).read_text()
		sample_file = usr_cfg_file + '.sample'
		sample_data = open(sample_file).read() if os.path.exists(sample_file) else None
		if src_data != sample_data:
			os.makedirs(os.path.dirname(sample_file),exist_ok=True)
			msg('{} {}'.format(
				('Updating','Creating')[sample_data is None],
				sample_file ))
			open(sample_file,'w').write(src_data)

	def get_curl_cmd():
		return ([
					'curl',
					'--tr-encoding',
					'--compressed', # adds 'Accept-Encoding: gzip'
					'--silent',
					'--header', 'Accept: application/json',
				] +
				(['--proxy', cfg.proxy] if cfg.proxy else []) +
				[api_url + ('/btc-bitcoin' if cfg.btc_only else '')]
			)

	global cfg,cfg_in
	cfg = cfg_parm
	cfg_in = cfg_in_parm

	try:
		from importlib.resources import files # Python 3.9
	except ImportError:
		from importlib_resources import files

	update_sample_file(cfg_in.cfg_file)
	update_sample_file(cfg_in.portfolio_file)

	if opt.portfolio and not cfg_in.portfolio:
		die(1,'No portfolio configured!\nTo configure a portfolio, edit the file ~/{}'.format(
			os.path.relpath(cfg_in.portfolio_file,start=homedir)))

	curl_cmd = get_curl_cmd()

	if opt.print_curl:
		Msg(curl_cmd + '\n' + ' '.join(curl_cmd))
		return

	parsed_json = [get_src_data(curl_cmd)] if cfg.btc_only else get_src_data(curl_cmd)

	if opt.list_ids:
		do_pager('\n'.join(e['id'] for e in parsed_json))
		return

	global now
	now = 1659465400 if g.test_suite else time.time() # 1659524400 1659445900

	(do_pager if opt.pager else Msg)(
		'\n'.join(getattr(Ticker,cfg.clsname)(dict(gen_data(parsed_json))).gen_output())
	)

def make_cfg(cmd_args,cfg_in):

	def get_rows_from_cfg(add_data=None):
		def create_row(e):
			return asset_tuple(e.split('-')[0].upper(),e)
		def gen():
			for n,(k,v) in enumerate(cfg_in.cfg['assets'].items()):
				yield(k)
				if add_data and k in add_data:
					v += tuple(add_data[k])
				for e in v:
					yield(create_row(e))
		return tuple(gen())

	def parse_asset_tuple(s):
		sym,id = (s.split('-')[0],s) if '-' in s else (s,None)
		return asset_tuple( sym.upper(), id.lower() if id else None )

	def parse_asset_triplet(s):
		ss = s.split(':')
		sym,amt = ( ss[0], Decimal(ss[1]) ) if len(ss) == 2 else ( s, None )
		return asset_triplet( *parse_asset_tuple(sym), amt )

	def parse_usr_asset_arg(s):
		return tuple(parse_asset_triplet(ss) for ss in s.split(',')) if s else ()

	def parse_query_arg(s):
		ss = s.split(':')
		if len(ss) == 2:
			return query_tuple(
				asset    = parse_asset_triplet(s),
				to_asset = None )
		elif len(ss) in (3,4):
			return query_tuple(
				asset    = parse_asset_triplet(':'.join(ss[:2])),
				to_asset = parse_asset_triplet(':'.join(ss[2:])),
			)
		else:
			die(1,f'{s}: malformed argument')

	def gen_uniq(obj_list,key,preload=None):
		found = set([getattr(obj,key) for obj in preload if hasattr(obj,key)] if preload else ())
		for obj in obj_list:
			id = getattr(obj,key)
			if id not in found:
				yield obj
			found.add(id)

	def get_usr_assets():
		return (
			'user_added',
			usr_rows +
			(tuple(asset for asset in query if asset) if query else ()) +
			usr_columns )

	def get_portfolio_assets(ret=()):
		if cfg_in.portfolio and opt.portfolio:
			ret = tuple( asset_tuple(e.split('-')[0].upper(),e) for e in cfg_in.portfolio )
		return ( 'portfolio', tuple(e for e in ret if (not opt.btc) or e.symbol == 'BTC') )

	def get_portfolio():
		return {k:Decimal(v) for k,v in cfg_in.portfolio.items() if (not opt.btc) or k == 'btc-bitcoin'}

	def parse_add_precision(s):
		if not s:
			return 0
		if not (s.isdigit() and s.isascii()):
			die(1,f'{s}: invalid parameter for --add-precision (not an integer)')
		if int(s) > 30:
			die(1,f'{s}: invalid parameter for --add-precision (value >30)')
		return int(s)

	def create_rows():
		rows = (
			('trade_pair',) + query if (query and query.to_asset) else
			('bitcoin',parse_asset_tuple('btc-bitcoin')) if opt.btc else
			get_rows_from_cfg( add_data={'fiat':['usd-us-dollar']} if opt.add_columns else None )
		)

		for hdr,data in (
			(get_usr_assets(),) if query else
			(get_usr_assets(), get_portfolio_assets())
		):
			if data:
				uniq_data = tuple(gen_uniq(data,'symbol',preload=rows))
				if uniq_data:
					rows += (hdr,) + uniq_data
		return rows

	cfg_tuple = namedtuple('global_cfg',[
		'rows',
		'usr_rows',
		'usr_columns',
		'query',
		'adjust',
		'clsname',
		'btc_only',
		'add_prec',
		'cachedir',
		'proxy',
		'portfolio' ])

	query_tuple   = namedtuple('query',['asset','to_asset'])
	asset_triplet = namedtuple('asset_triplet',['symbol','id','amount'])
	asset_tuple   = namedtuple('asset_tuple',['symbol','id'])

	usr_rows    = parse_usr_asset_arg(opt.add_rows)
	usr_columns = parse_usr_asset_arg(opt.add_columns)
	query       = parse_query_arg(cmd_args[0]) if cmd_args else None

	return cfg_tuple(
		rows        = create_rows(),
		usr_rows    = usr_rows,
		usr_columns = usr_columns,
		query       = query,
		adjust      = ( lambda x: (100 + x) / 100 if x else 1 )( Decimal(opt.adjust or 0) ),
		clsname     = 'trading' if query else 'overview',
		btc_only    = opt.btc,
		add_prec    = parse_add_precision(opt.add_precision),
		cachedir    = opt.cachedir or cfg_in.cfg.get('cachedir') or cachedir,
		proxy       = None if opt.proxy == '' else (opt.proxy or cfg_in.cfg.get('proxy')),
		portfolio   = get_portfolio() if cfg_in.portfolio and opt.portfolio and not query else None
	)

def get_cfg_in():
	ret = namedtuple('cfg_in_data',['cfg','portfolio','cfg_file','portfolio_file'])
	cfg_file,portfolio_file = (
		[os.path.join(g.data_dir_root,'node_tools',fn) for fn in (cfg_fn,portfolio_fn)]
	)
	cfg_data,portfolio_data = (
		[yaml.safe_load(open(fn).read()) if os.path.exists(fn) else None for fn in (cfg_file,portfolio_file)]
	)
	return ret(
		cfg = cfg_data or {
			'assets': {
				'coin':      [ 'btc-bitcoin', 'eth-ethereum', 'xmr-monero' ],
				'commodity': [ 'xau-gold-spot-token', 'xag-silver-spot-token', 'xbr-brent-crude-oil-spot' ],
				'fiat':      [ 'gbp-pound-sterling-token', 'eur-euro-token' ],
				'index':     [ 'dj30-dow-jones-30-token', 'spx-sp-500', 'ndx-nasdaq-100-token' ],
			},
			'proxy': 'http://vpn-gw:8118'
		},
		portfolio = portfolio_data,
		cfg_file = cfg_file,
		portfolio_file = portfolio_file,
	)

class Ticker:

	class base:

		offer = None
		to_asset = None

		def __init__(self,data):

			self.comma = ',' if opt.thousands_comma else ''

			self.col1_wid = max(len('TOTAL'),(
				max(len(self.create_label(d['id'])) for d in data.values()) if opt.name_labels else
				max(len(d['symbol']) for d in data.values())
			)) + 1

			self.rows = [row._replace(id=self.get_id(row)) if isinstance(row,tuple) else row for row in cfg.rows]
			self.col_usd_prices = {k:Decimal(self.data[k]['price_usd']) for k in self.col_ids}

			self.prices = {row.id:self.get_row_prices(row.id)
				for row in self.rows if isinstance(row,tuple) and row.id in data}
			self.prices['usd-us-dollar'] = self.get_row_prices('usd-us-dollar')

		def format_last_update_col(self,cross_assets=()):

			if opt.elapsed:
				from .Util import format_elapsed_hr
				fmt_func = format_elapsed_hr
			else:
				fmt_func = lambda t,now: time.strftime('%F %X',time.gmtime(t)) # ticker API
				# t.replace('T',' ').replace('Z','') # tickers API

			d = self.data
			max_w = 0
			min_t = min( (int(d[a.id]['last_updated']) for a in cross_assets), default=None )

			for row in self.rows:
				if isinstance(row,tuple):
					try:
						t = int(d[row.id]['last_updated'])
					except KeyError:
						pass
					else:
						t_fmt = d[row.id]['last_updated_fmt'] = fmt_func( (min(t,min_t) if min_t else t), now )
						max_w = max(len(t_fmt),max_w)

			self.upd_w = max_w

		def init_prec(self):
			exp = [(a.id,Decimal.adjusted(self.prices[a.id]['usd-us-dollar'])) for a in self.usr_col_assets]
			self.uprec = { k: max(0,v+4) + cfg.add_prec for k,v in exp }
			self.uwid  = { k: 12 + max(0, abs(v)-6) + cfg.add_prec for k,v in exp }

		def get_id(self,asset):
			if asset.id:
				return asset.id
			else:
				for d in self.data.values():
					if d['symbol'] == asset.symbol:
						return d['id']

		def create_label(self,id):
			return ' '.join(id.split('-')[1:]).upper()

		def gen_output(self):
			yield 'Current time: {} UTC'.format(time.strftime('%F %X',time.gmtime(now)))

			for asset in self.usr_col_assets:
				if asset.symbol != 'USD':
					usdprice = Decimal(self.data[asset.id]['price_usd'])
					yield '{} ({}) = {:{}.{}f} USD'.format(
						asset.symbol,
						self.create_label(asset.id),
						usdprice,
						self.comma,
						max(2,int(-usdprice.adjusted())+4) )

			if hasattr(self,'subhdr'):
				yield self.subhdr

			if self.show_adj:
				yield (
					('Offered price differs from spot' if self.offer else 'Adjusting prices')
					+ ' by '
					+ yellow('{:+.2f}%'.format( (self.adjust-1) * 100 ))
				)

			yield ''

			if cfg.portfolio:
				yield blue('PRICES')

			if self.table_hdr:
				yield self.table_hdr

			for row in self.rows:
				if isinstance(row,str):
					yield ('-' * self.hl_wid)
				else:
					try:
						yield self.fmt_row(self.data[row.id])
					except KeyError:
						yield gray(f'(no data for {row.id})')

			yield '-' * self.hl_wid

			if cfg.portfolio:
				self.fs_num = self.fs_num2
				self.fs_str = self.fs_str2
				yield ''
				yield blue('PORTFOLIO')
				yield self.table_hdr
				yield '-' * self.hl_wid
				for sym,amt in cfg.portfolio.items():
					try:
						yield self.fmt_row(self.data[sym],amt=amt)
					except KeyError:
						yield gray(f'(no data for {sym})')
				yield '-' * self.hl_wid
				if not cfg.btc_only:
					yield self.fs_num.format(
						lbl = 'TOTAL', pc1='', pc2='', upd='', amt='',
						**{ k.replace('-','_'): v for k,v in self.prices['total'].items() }
					)

	class overview(base):

		def __init__(self,data):
			self.data = data
			self.adjust = cfg.adjust
			self.show_adj = self.adjust != 1
			self.usr_col_assets = [asset._replace(id=self.get_id(asset)) for asset in cfg.usr_columns]
			self.col_ids = ('usd-us-dollar',) + tuple(a.id for a in self.usr_col_assets) + ('btc-bitcoin',)

			super().__init__(data)

			self.format_last_update_col()

			if cfg.portfolio:
				self.prices['total'] = { col_id: sum(self.prices[row.id][col_id] * cfg.portfolio[row.id]
					for row in self.rows if isinstance(row,tuple) and row.id in cfg.portfolio and row.id in data)
						for col_id in self.col_ids }

			self.init_prec()
			self.init_fs()

		def get_row_prices(self,id):
			if id in self.data:
				d = self.data[id]
				return { k: (
						Decimal(d['price_btc']) if k == 'btc-bitcoin' else
						Decimal(d['price_usd']) / self.col_usd_prices[k]
					) * self.adjust for k in self.col_ids }

		def fmt_row(self,d,amt=None,amt_fmt=None):

			def fmt_pct(d):
				if d in ('',None):
					return gray('     --')
				n = Decimal(d)
				return (red,green)[n>=0](f'{n:+7.2f}')

			p = self.prices[d['id']]

			if amt is not None:
				amt_fmt = f'{amt:{19+cfg.add_prec}{self.comma}.{8+cfg.add_prec}f}'
				if '.' in amt_fmt:
					amt_fmt = amt_fmt.rstrip('0').rstrip('.')

			return self.fs_num.format(
				lbl = (self.create_label(d['id']) if opt.name_labels else d['symbol']),
				pc1 = fmt_pct(d.get('percent_change_7d')),
				pc2 = fmt_pct(d.get('percent_change_24h')),
				upd = d.get('last_updated_fmt'),
				amt = amt_fmt,
				**{ k.replace('-','_'): v * (1 if amt is None else amt) for k,v in p.items() }
			)

		def init_fs(self):

			col_prec = {'usd-us-dollar':2+cfg.add_prec,'btc-bitcoin':8+cfg.add_prec }  # | self.uprec # Python 3.9
			col_prec.update(self.uprec)
			col_wid  = {'usd-us-dollar':8+cfg.add_prec,'btc-bitcoin':12+cfg.add_prec } # """
			col_wid.update(self.uwid)
			max_row = max(
				( (k,v['btc-bitcoin']) for k,v in self.prices.items() ),
				key = lambda a: a[1]
			)
			widths = { k: len('{:{}.{}f}'.format( self.prices[max_row[0]][k], self.comma, col_prec[k] ))
						for k in self.col_ids }

			fd = namedtuple('format_str_data',['fs_str','fs_num','wid'])

			col_fs_data = {
				'label':       fd(f'{{lbl:{self.col1_wid}}}',f'{{lbl:{self.col1_wid}}}',self.col1_wid),
				'pct7d':       fd(' {pc1:7}', ' {pc1:7}', 8),
				'pct24h':      fd(' {pc2:7}', ' {pc2:7}', 8),
				'update_time': fd('  {upd}',  '  {upd}',  max((19 if cfg.portfolio else 0),self.upd_w) + 2),
				'amt':         fd('  {amt}',  '  {amt}',  21),
			}
#			} | { k: fd( # Python 3.9
			col_fs_data.update({ k: fd(
						'  {{{}:>{}}}'.format( k.replace('-','_'), widths[k] ),
						'  {{{}:{}{}.{}f}}'.format( k.replace('-','_'), widths[k], self.comma, col_prec[k] ),
						widths[k]+2
					) for k in self.col_ids
			})

			cols = (
				['label','usd-us-dollar'] +
				[asset.id for asset in self.usr_col_assets] +
				[a for a,b in (
					( 'btc-bitcoin',  not cfg.btc_only ),
					( 'pct7d', opt.percent_change ),
					( 'pct24h', opt.percent_change ),
					( 'update_time', opt.update_time ),
				) if b]
			)
			cols2 = list(cols)
			if opt.update_time:
				cols2.pop()
			cols2.append('amt')

			self.fs_str = ''.join(col_fs_data[c].fs_str for c in cols)
			self.fs_num = ''.join(col_fs_data[c].fs_num for c in cols)
			self.hl_wid = sum(col_fs_data[c].wid for c in cols)

			self.fs_str2 = ''.join(col_fs_data[c].fs_str for c in cols2)
			self.fs_num2 = ''.join(col_fs_data[c].fs_num for c in cols2)
			self.hl_wid2 = sum(col_fs_data[c].wid for c in cols2)

		@property
		def table_hdr(self):
			return self.fs_str.format(
				lbl = '',
				pc1 = ' CHG_7d',
				pc2 = 'CHG_24h',
				upd = 'UPDATED',
				amt = '         AMOUNT',
				usd_us_dollar = 'USD',
				btc_bitcoin = '  BTC',
				**{ a.id.replace('-','_'): a.symbol for a in self.usr_col_assets }
			)

	class trading(base):

		def __init__(self,data):
			self.data = data
			self.asset = cfg.query.asset._replace(id=self.get_id(cfg.query.asset))
			self.to_asset = (
				cfg.query.to_asset._replace(id=self.get_id(cfg.query.to_asset))
				if cfg.query.to_asset else None )
			self.col_ids = [self.asset.id]
			self.adjust = cfg.adjust
			if self.to_asset:
				self.offer = self.to_asset.amount
				if self.offer:
					real_price = (
						self.asset.amount
						* Decimal(data[self.asset.id]['price_usd'])
						/ Decimal(data[self.to_asset.id]['price_usd'])
					)
					if self.adjust != 1:
						die(1,'the --adjust option may not be combined with TO_AMOUNT in the trade specifier')
					self.adjust = self.offer / real_price
				self.hl_ids = [self.asset.id,self.to_asset.id]
			else:
				self.hl_ids = [self.asset.id]

			self.show_adj = self.adjust != 1 or self.offer

			super().__init__(data)

			self.usr_col_assets = [self.asset] + ([self.to_asset] if self.to_asset else [])
			for a in self.usr_col_assets:
				self.prices[a.id]['usd-us-dollar'] = Decimal(data[a.id]['price_usd'])

			self.format_last_update_col(cross_assets=self.usr_col_assets)

			self.init_prec()
			self.init_fs()

		def get_row_prices(self,id):
			if id in self.data:
				d = self.data[id]
				return { k: self.col_usd_prices[self.asset.id] / Decimal(d['price_usd']) for k in self.col_ids }

		def init_fs(self):
			self.max_wid = max(
				len('{:{}{}.{}f}'.format(
						v[self.asset.id] * self.asset.amount,
						16 + cfg.add_prec,
						self.comma,
						8 + cfg.add_prec
					))
					for v in self.prices.values()
			)
			self.fs_str = '{lbl:%s} {p_spot}' % self.col1_wid
			self.hl_wid = self.col1_wid + self.max_wid + 1
			if self.show_adj:
				self.fs_str += ' {p_adj}'
				self.hl_wid += self.max_wid + 1
			if opt.update_time:
				self.fs_str += '  {upd}'
				self.hl_wid += self.upd_w + 2

		def fmt_row(self,d):
			id = d['id']
			p = self.prices[id][self.asset.id] * self.asset.amount
			p_spot = '{:{}{}.{}f}'.format( p, self.max_wid, self.comma, 8+cfg.add_prec )
			p_adj = (
				'{:{}{}.{}f}'.format( p*self.adjust, self.max_wid, self.comma, 8+cfg.add_prec )
				if self.show_adj else '' )

			return self.fs_str.format(
				lbl = (self.create_label(id) if opt.name_labels else d['symbol']),
				p_spot = green(p_spot) if id in self.hl_ids else p_spot,
				p_adj  = yellow(p_adj) if id in self.hl_ids else p_adj,
				upd = d.get('last_updated_fmt'),
			)

		@property
		def table_hdr(self):
			return self.fs_str.format(
				lbl = '',
				p_spot = '{t:>{w}}'.format(
					t = 'SPOT PRICE',
					w = self.max_wid ),
				p_adj = '{t:>{w}}'.format(
					t = ('OFFERED' if self.offer else 'ADJUSTED') + ' PRICE',
					w = self.max_wid ),
				upd = 'UPDATED'
			)

		@property
		def subhdr(self):
			return (
				'{a}: {b:{c}} {d}'.format(
					a = 'Offer' if self.offer else 'Amount',
					b = self.asset.amount,
					c = self.comma,
					d = self.asset.symbol
				) + (
				(
					' =>' +
					(' {:{}}'.format(self.offer,self.comma) if self.offer else '') +
					' {} ({})'.format(
						self.to_asset.symbol,
						self.create_label(self.to_asset.id) )
				) if self.to_asset else '' )
			)