def __post_init__(self):
kwargs = DictObject(self.raw_data)
_maxs, _circ = self.max_supply, self.circulating_supply
self.max_supply = conv_dec(kwargs.get('maxSupply', self.max_supply))
self.max_supply = conv_dec(kwargs.get('max_supply', self.max_supply))
self.circulating_supply = conv_dec(
kwargs.get('circulatingSupply', self.circulating_supply))
self.circulating_supply = conv_dec(
kwargs.get('circulating_supply', self.circulating_supply))
self.supply = Decimal(kwargs.get('supply', self.supply))
meta = self.metadata
try:
meta = {} if empty(meta, itr=True) else (
json.loads(meta) if isinstance(meta, str) else meta)
except json.JSONDecodeError:
log.warning("Failed to decode Token metadata as JSON: %s", meta)
meta = {}
self.metadata = TokenMetadata.from_dict(meta)
assetObject.asset_id) else assetObject.asset_id
# Map the asset's symbol (e.g. HIVE) to the Asset object, so it can be matched by both asset ID and symbol.
new_assets[assetObject.symbol] = assetObject
return new_assets
######
# For each network in CHAIN_ASSETS and KNOWN_ASSETS, make sure every asset type can be matched by both asset ID
# (i.e. IDs starting with "@@0000"), and their symbol (e.g. "HIVE").
# noinspection PyTypeChecker
for chain in list(CHAIN): # type: CHAIN
KNOWN_ASSETS[chain.value] = add_known_asset_symbols(
KNOWN_ASSETS.get(chain.value, {}))
CHAIN_ASSETS[chain.name] = add_known_asset_symbols(
CHAIN_ASSETS.get(chain.name, {}))
@dataclass
class Amount(DictDataClass):
asset: Asset
amount: Decimal
@property
def symbol(self) -> str:
return self.asset.symbol
@property
def precision(self) -> int:
return self.asset.precision
def _node_table_row(cls, node: NodeStatus) -> Tuple[str, NodeTableRow]:
statuses = {
0: Fore.RED + "DEAD",
1: Fore.LIGHTRED_EX + "UNSTABLE",
2: Fore.YELLOW + "Unreliable",
3: Fore.GREEN + "Online",
}
# Decide on the node's status based on how many test stages the
status = statuses[len(node.raw)]
# Calculate the average response time of this node by totalling the timing seconds, and dividing them
# by the amount of individual timing events
avg_res = 'error'
if len(node.timing) > 0:
time_total = 0.0
for time_type, time in node.timing.items():
time_total += time
avg_res = time_total / len(node.timing)
avg_res = '{:.2f}'.format(avg_res)
# Calculate the average tries required per successful call by summing up the total amount of tries,
# and dividing that by the length of the 'tries' dict (individual calls / tests that were tried)
avg_tries = 'error'
if len(node['tries']) > 0:
tries_total = 0
for tries_type, tries in node.tries.items():
tries_total += tries
avg_tries = tries_total / len(node.tries)
avg_tries = '{:.2f}'.format(avg_tries)
if node.time_behind:
if node.time_behind.total_seconds() >= 60:
status = f"{Fore.LIGHTRED_EX}Out-of-sync"
# If there were any moderate errors while testing the node, change the status from green to yellow, and
# change the status to the error state
if 'err_reason' in node and not empty(node.err_reason, True, True):
status = Fore.YELLOW + node.err_reason
host = str(node.host)
# Replace the long http:// | https:// URI prefix with a short, clean character in brackets
host = host.replace('https://', '(S)')
host = host.replace('http://', '(H)')
# Select the appropriate coloured host type symbol based on the node's detected 'srvtype'
def_stype = f"{Fore.RED}(?){Fore.RESET}"
host_stypes = DictObject(jussi=f"{Fore.GREEN}(J){Fore.RESET}",
appbase=f"{Fore.BLUE}(A){Fore.RESET}",
legacy=f"{Fore.MAGENTA}(L){Fore.RESET}")
# If plugin scanning was enabled, generate and append the working vs. total plugin stat column
# to the fmt_str row.
f_plugins = ''
if settings.plugins:
plg, ttl_plg = len(node.plugins), len(TEST_PLUGINS_LIST)
f_plugins = f'{plg} / {ttl_plg}'
if plg <= (ttl_plg // 3):
f_plugins = f'{Fore.RED}{f_plugins}'
elif plg <= (ttl_plg // 2):
f_plugins = f'{Fore.LIGHTRED_EX}{f_plugins}'
elif plg < ttl_plg:
f_plugins = f'{Fore.YELLOW}{f_plugins}'
elif plg == ttl_plg:
f_plugins = f'{Fore.GREEN}{f_plugins}'
f_plugins += Fore.RESET
return node.host, cls.NodeTableRow(server=host,
server_type=host_stypes.get(
node.srvtype, def_stype),
ssl='https://' in node.host,
status=status,
head_block=node.current_block,
block_time=node.block_time,
version=node.version,
network=node.network,
res_time=avg_res,
avg_retries=avg_tries,
api_tests=f_plugins)