meshtensor-cli 9.18.1__py3-none-any.whl

meshtensor_cli/src/meshtensor/minigraph.py

@@ -0,0 +1,254 @@
+import asyncio
+
+import numpy as np
+from numpy.typing import NDArray
+
+from meshtensor_cli.src.meshtensor.chain_data import NeuronInfo, SubnetState
+from meshtensor_cli.src.meshtensor.meshtensor_interface import MeshtensorInterface
+from meshtensor_cli.src.meshtensor.utils import (
+    convert_root_weight_uids_and_vals_to_tensor,
+    convert_weight_uids_and_vals_to_tensor,
+    convert_bond_uids_and_vals_to_tensor,
+)
+
+
+class MiniGraph:
+    def __init__(
+        self,
+        netuid: int,
+        neurons: list[NeuronInfo],
+        meshtensor: "MeshtensorInterface",
+        subnet_state: "SubnetState",
+        block: int,
+    ):
+        self.neurons = neurons
+        self.netuid = netuid
+        self.weights = None
+        self.meshtensor = meshtensor
+        self.network = meshtensor.network
+
+        self.axons = [n.axon_info for n in self.neurons]
+        self.n = self._create_tensor(len(self.neurons), dtype=np.int64)
+        self.block = self._create_tensor(block, dtype=np.int64)
+        self.uids = self._create_tensor(
+            [neuron.uid for neuron in self.neurons], dtype=np.int64
+        )
+        self.trust = self._create_tensor(
+            [neuron.trust for neuron in self.neurons], dtype=np.float32
+        )
+        self.consensus = self._create_tensor(
+            [neuron.consensus for neuron in self.neurons], dtype=np.float32
+        )
+        self.incentive = self._create_tensor(
+            [neuron.incentive for neuron in self.neurons], dtype=np.float32
+        )
+        self.dividends = self._create_tensor(
+            [neuron.dividends for neuron in self.neurons], dtype=np.float32
+        )
+        self.ranks = self._create_tensor(
+            [neuron.rank for neuron in self.neurons], dtype=np.float32
+        )
+        self.emission = self._create_tensor(
+            [neuron.emission for neuron in self.neurons], dtype=np.float32
+        )
+        self.active = self._create_tensor(
+            [neuron.active for neuron in self.neurons], dtype=np.int64
+        )
+        self.last_update = self._create_tensor(
+            [neuron.last_update for neuron in self.neurons], dtype=np.int64
+        )
+        self.validator_permit = self._create_tensor(
+            [neuron.validator_permit for neuron in self.neurons], dtype=bool
+        )
+        self.validator_trust = self._create_tensor(
+            [neuron.validator_trust for neuron in self.neurons], dtype=np.float32
+        )
+
+        # Fetch stakes from subnet_state until we get updated data in NeuronInfo
+        global_stake_list, local_stake_list, stake_weights_list = self._process_stakes(
+            neurons, subnet_state
+        )
+        self.global_stake = self._create_tensor(global_stake_list, dtype=np.float32)
+        self.local_stake = self._create_tensor(local_stake_list, dtype=np.float32)
+        self.stake_weights = self._create_tensor(stake_weights_list, dtype=np.float32)
+
+    async def __aenter__(self):
+        if not self.weights:
+            await self._set_weights_and_bonds()
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        pass
+
+    @property
+    def hotkeys(self):
+        return [axon.hotkey for axon in self.axons]
+
+    @staticmethod
+    def _create_tensor(data, dtype) -> NDArray:
+        """
+        Creates a numpy array with the given data and data type. This method is a utility function used internally to encapsulate data into a np.array, making it compatible with the metagraph's numpy model structure.
+
+        Args:
+            data: The data to be included in the tensor. This could be any numeric data, like stakes, ranks, etc.
+            dtype: The data type for the tensor, typically a numpy data type like ``np.float32`` or ``np.int64``.
+
+        Returns:
+            A tensor parameter encapsulating the provided data.
+
+        Internal Usage:
+            Used internally to create tensor parameters for various metagraph attributes::
+
+                self.stake = self._create_tensor(neuron_stakes, dtype=np.float32)
+        """
+        # TODO: Check and test the creation of tensor
+        return np.array(data, dtype=dtype)
+
+    async def _set_weights_and_bonds(self):
+        """
+        Computes and sets the weights and bonds for each neuron in the metagraph. This method is responsible for
+        processing the raw weight and bond data obtained from the network and converting it into a structured format
+        suitable for the metagraph model.
+        """
+        # TODO: Check and test the computation of weights and bonds
+        if self.netuid == 0:
+            self.weights = await self._process_root_weights(
+                [neuron.weights for neuron in self.neurons], "weights"
+            )
+        else:
+            self.weights = self._process_weights_or_bonds(
+                [neuron.weights for neuron in self.neurons], "weights"
+            )
+            self.bonds = self._process_weights_or_bonds(
+                [neuron.bonds for neuron in self.neurons], "bonds"
+            )
+
+    def _process_stakes(
+        self,
+        neurons: list[NeuronInfo],
+        subnet_state: SubnetState,
+    ) -> tuple[list[float], list[float], list[float]]:
+        """
+        Processes the global_stake, local_stake, and stake_weights based on the neuron's hotkey.
+
+        Args:
+            neurons (List[NeuronInfo]): List of neurons.
+            subnet_state (SubnetState): The subnet state containing stake information.
+
+        Returns:
+            tuple[list[float], list[float], list[float]]: Lists of global_stake, local_stake, and stake_weights.
+        """
+        global_stake_list = []
+        local_stake_list = []
+        stake_weights_list = []
+        hotkey_to_index = {
+            hotkey: idx for idx, hotkey in enumerate(subnet_state.hotkeys)
+        }
+
+        for neuron in neurons:
+            idx = hotkey_to_index.get(neuron.hotkey)
+            if idx is not None:
+                global_stake_list.append(subnet_state.global_stake[idx].tao)
+                local_stake_list.append(subnet_state.local_stake[idx].tao)
+                stake_weights_list.append(subnet_state.stake_weight[idx])
+            else:
+                global_stake_list.append(0.0)
+                local_stake_list.append(0.0)
+                stake_weights_list.append(0.0)
+
+        return global_stake_list, local_stake_list, stake_weights_list
+
+    def _process_weights_or_bonds(self, data, attribute: str) -> NDArray:
+        """
+        Processes the raw weights or bonds data and converts it into a structured tensor format. This method handles
+        the transformation of neuron connection data (`weights` or `bonds`) from a list or other unstructured
+        format into a tensor that can be utilized within the metagraph model.
+
+        :param data: The raw weights or bonds data to be processed. This data typically comes from the meshtensor.
+                     attribute: A string indicating whether the data is `weights` or `bonds`, which determines the
+                     specific processing steps to be applied.
+
+        :return: A tensor parameter encapsulating the processed weights or bonds data.
+        """
+        data_array = []
+        for item in data:
+            if len(item) == 0:
+                data_array.append(np.zeros(len(self.neurons), dtype=np.float32))  # type: ignore
+            else:
+                uids, values = zip(*item)
+                # TODO: Validate and test the conversion of uids and values to tensor
+                if attribute == "weights":
+                    data_array.append(
+                        convert_weight_uids_and_vals_to_tensor(
+                            len(self.neurons),
+                            list(uids),
+                            list(values),  # type: ignore
+                        )
+                    )
+                else:
+                    data_array.append(
+                        convert_bond_uids_and_vals_to_tensor(  # type: ignore
+                            len(self.neurons), list(uids), list(values)
+                        ).astype(np.float32)
+                    )
+        tensor_param: NDArray = (
+            np.stack(data_array) if len(data_array) else np.array([], dtype=np.float32)
+        )
+        if len(data_array) == 0:
+            # meshtensor.logging.warning(
+            #     f"Empty {attribute}_array on metagraph.sync(). The '{attribute}' tensor is empty."
+            # )
+            pass
+        return tensor_param
+
+    async def _process_root_weights(self, data, attribute: str) -> NDArray:
+        """
+        Specifically processes the root weights data for the metagraph. This method is similar to
+        `_process_weights_or_bonds` but is tailored for processing root weights, which have a different structure and
+        significance in the network.
+
+        Args:
+        :param data: The raw root weights data to be processed.
+        :param attribute: A string indicating the attribute type, here it's typically `weights`.
+
+        :return: A tensor parameter encapsulating the processed root weights data.
+        """
+
+        async def get_total_subnets():
+            _result = await self.meshtensor.query(
+                module="MeshtensorModule",
+                storage_function="TotalNetworks",
+                params=[],
+                reuse_block_hash=True,
+            )
+            return _result
+
+        async def get_subnets():
+            _result = await self.meshtensor.query(
+                module="MeshtensorModule",
+                storage_function="TotalNetworks",
+            )
+            return [i for i in range(_result)]
+
+        data_array = []
+        n_subnets, subnets = await asyncio.gather(get_total_subnets(), get_subnets())
+        for item in data:
+            if len(item) == 0:
+                data_array.append(np.zeros(n_subnets, dtype=np.float32))  # type: ignore
+            else:
+                uids, values = zip(*item)
+                data_array.append(
+                    convert_root_weight_uids_and_vals_to_tensor(  # type: ignore
+                        n_subnets, list(uids), list(values), subnets
+                    )
+                )
+
+        tensor_param: NDArray = (
+            np.stack(data_array) if len(data_array) else np.array([], dtype=np.float32)
+        )
+        if len(data_array) == 0:
+            pass
+            # meshtensor.logging.warning(
+            #     f"Empty {attribute}_array on metagraph.sync(). The '{attribute}' tensor is empty."
+            # )
+        return tensor_param

meshtensor_cli/src/meshtensor/networking.py

@@ -0,0 +1,12 @@
+import netaddr
+
+
+def int_to_ip(int_val: int) -> str:
+    """Maps an integer to a unique ip-string
+    :param int_val: The integer representation of an ip. Must be in the range (0, 3.4028237e+38).
+
+    :return: The string representation of an ip. Of form *.*.*.* for ipv4 or *::*:*:*:* for ipv6
+
+    :raises: netaddr.core.AddrFormatError (Exception): Raised when the passed int_vals is not a valid ip int value.
+    """
+    return str(netaddr.IPAddress(int_val))

meshtensor_cli/src/meshtensor/templates/main-filters.j2

@@ -0,0 +1,24 @@
+<div class="filters-section">
+    <div class="search-box">
+        <input type="text" id="subnet-search" placeholder="search for name, or netuid..." onkeyup="filterSubnets()">
+    </div>
+    <div class="filter-toggles">
+        <label>
+            <input type="checkbox" id="show-verbose" onchange="toggleVerboseNumbers()">
+            Precise Numbers
+        </label>
+        <label>
+            <input type="checkbox" id="show-staked" onchange="filterSubnets()">
+            Show Only Staked
+        </label>
+        <label>
+            <input type="checkbox" id="show-tiles" onchange="toggleTileView()" checked>
+            Tile View
+        </label>
+        <label class="disabled-label" title="Coming soon">
+            <input type="checkbox" id="live-mode" disabled>
+            Live Mode (coming soon)
+        </label>
+    </div>
+</div>
+<div id="subnet-tiles-container" class="subnet-tiles-container"></div>

meshtensor_cli/src/meshtensor/templates/main-header.j2

@@ -0,0 +1,36 @@
+{#
+    vars:
+        wallet_info.coldkey, truncated_coldkey, wallet_info.balance, root_symbol_html, wallet_info.total_ideal_stake_value,
+        slippage_percentage, wallet_info.total_slippage_value, block_number
+#}
+
+<div class="header">
+    <meta charset="UTF-8">
+    <div class="wallet-info">
+        <span class="wallet-name">{{ wallet_info.name }}</span>
+        <div class="wallet-address-container" onclick="copyToClipboard('{{ coldkey }}', this)">
+            <span class="wallet-address" title="Click to copy">{{ truncated_coldkey }}}</span>
+            <span class="copy-indicator">Copy</span>
+        </div>
+    </div>
+    <div class="stake-metrics">
+        <div class="stake-metric">
+            <span class="metric-label">Block</span>
+            <span class="metric-value" style="color: #FF9900;">{{ block_number }}</span>
+        </div>
+        <div class="stake-metric">
+            <span class="metric-label">Balance</span>
+            <span class="metric-value">{{ "%.4f"|format(wallet_info.balance) }} {{ root_symbol_html }}</span>
+        </div>
+        <div class="stake-metric">
+            <span class="metric-label">Total Stake Value</span>
+            <span class="metric-value">{{ "%.4f"|format(wallet_info.total_ideal_stake_value) }} {{ root_symbol_html }}</span>
+        </div>
+        <div class="stake-metric">
+            <span class="metric-label">Slippage Impact</span>
+            <span class="metric-value slippage-value">
+                {{ "%.2f"|format(slippage_percentage) }}% <span class="slippage-detail">({{ "%.4f"|format(wallet_info.total_slippage_value) }} {{ root_symbol_html }})</span>
+            </span>
+        </div>
+    </div>
+</div>

meshtensor_cli/src/meshtensor/templates/neuron-details.j2

@@ -0,0 +1,111 @@
+<div id="neuron-detail-container" style="display: none;">
+    <div class="neuron-detail-header">
+        <button class="back-button neuron-detail-back" onclick="closeNeuronDetails()">&larr; Back</button>
+    </div>
+    <div class="neuron-detail-content">
+        <div class="neuron-info-top">
+            <h2 class="neuron-name" id="neuron-name"></h2>
+            <div class="neuron-keys">
+                <div class="hotkey-label">
+                    <span style="color: #FF9900;">Hotkey:</span>
+                    <span id="neuron-hotkey" class="truncated-address"></span>
+                </div>
+                <div class="coldkey-label">
+                    <span style="color: #FF9900;">Coldkey:</span>
+                    <span id="neuron-coldkey" class="truncated-address"></span>
+                </div>
+            </div>
+        </div>
+        <div class="neuron-cards-container">
+            <!-- First row: Stakes, Dividends, Incentive, Emissions -->
+            <div class="neuron-metrics-row">
+                <div class="metric-card">
+                    <div class="metric-label">Stake Weight</div>
+                    <div id="neuron-stake-total" class="metric-value formatted-number"
+                        data-value="0" data-symbol=""></div>
+                </div>
+
+                <div class="metric-card">
+                    <div class="metric-label">Stake (Alpha)</div>
+                    <div id="neuron-stake-token" class="metric-value formatted-number"
+                        data-value="0" data-symbol=""></div>
+                </div>
+
+                <div class="metric-card">
+                    <div class="metric-label">Stake (Root)</div>
+                    <div id="neuron-stake-root" class="metric-value formatted-number"
+                        data-value="0" data-symbol="&#x03C4;"></div>
+                </div>
+
+                <div class="metric-card">
+                    <div class="metric-label">Dividends</div>
+                    <div id="neuron-dividends" class="metric-value formatted-number"
+                        data-value="0" data-symbol=""></div>
+                </div>
+
+                <div class="metric-card">
+                    <div class="metric-label">Incentive</div>
+                    <div id="neuron-incentive" class="metric-value formatted-number"
+                        data-value="0" data-symbol=""></div>
+                </div>
+
+                <div class="metric-card">
+                    <div class="metric-label">Emissions</div>
+                    <div id="neuron-emissions" class="metric-value formatted-number"
+                        data-value="0" data-symbol=""></div>
+                </div>
+            </div>
+
+            <!-- Second row: Rank, Trust, Pruning Score, Validator Permit, Consensus, Last Update -->
+            <div class="neuron-metrics-row">
+                <div class="metric-card">
+                    <div class="metric-label">Rank</div>
+                    <div id="neuron-rank" class="metric-value"></div>
+                </div>
+
+                <div class="metric-card">
+                    <div class="metric-label">Trust</div>
+                    <div id="neuron-trust" class="metric-value"></div>
+                </div>
+
+                <div class="metric-card">
+                    <div class="metric-label">Pruning Score</div>
+                    <div id="neuron-pruning-score" class="metric-value"></div>
+                </div>
+
+                <div class="metric-card">
+                    <div class="metric-label">Validator Permit</div>
+                    <div id="neuron-validator-permit" class="metric-value"></div>
+                </div>
+
+                <div class="metric-card">
+                    <div class="metric-label">Consensus</div>
+                    <div id="neuron-consensus" class="metric-value"></div>
+                </div>
+
+                <div class="metric-card">
+                    <div class="metric-label">Last Update</div>
+                    <div id="neuron-last-update" class="metric-value"></div>
+                </div>
+            </div>
+
+            <!-- Third row: Reg Block, IP Info, Active -->
+            <div class="neuron-metrics-row last-row">
+                <div class="metric-card">
+                    <div class="metric-label">Reg Block</div>
+                    <div id="neuron-reg-block" class="metric-value"></div>
+                </div>
+
+                <div class="metric-card">
+                    <div class="metric-label">IP Info</div>
+                    <div id="neuron-ipinfo" class="metric-value"></div>
+                </div>
+
+                <div class="metric-card">
+                    <div class="metric-label">Active</div>
+                    <div id="neuron-active" class="metric-value"></div>
+                </div>
+            </div>
+        </div>
+    </div>
+</div>

meshtensor_cli/src/meshtensor/templates/price-multi.j2

@@ -0,0 +1,113 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <title>{{ title }}</title>
+    <script src="https://cdn.plot.ly/plotly-latest.min.js"></script>
+    <style>
+        body {
+            background-color: #000;
+            color: #fff;
+            font-family: Arial, sans-serif;
+            margin: 0;
+            padding: 20px;
+        }
+        .container {
+            display: flex;
+            flex-direction: column;
+            gap: 60px;
+        }
+        #multi-subnet-chart {
+            width: 90vw;
+            height: 70vh;
+            margin-bottom: 40px;
+        }
+        .subnet-buttons {
+            display: grid;
+            grid-template-columns: repeat(auto-fill, minmax(80px, 1fr));
+            gap: 8px;
+            max-height: 120px;
+            overflow-y: auto;
+            padding-right: 10px;
+            margin-top: 50px;
+            border-top: 1px solid rgba(255,255,255,0.1);
+            padding-top: 50px;
+            position: relative;
+            bottom: 0;
+        }
+        .subnet-buttons::-webkit-scrollbar {
+            width: 8px;
+        }
+        .subnet-buttons::-webkit-scrollbar-track {
+            background: rgba(50,50,50,0.3);
+            border-radius: 4px;
+        }
+        .subnet-buttons::-webkit-scrollbar-thumb {
+            background: rgba(100,100,100,0.8);
+            border-radius: 4px;
+        }
+        .subnet-button {
+            background-color: rgba(50,50,50,0.8);
+            border: 1px solid rgba(70,70,70,0.9);
+            color: white;
+            padding: 8px 16px;
+            cursor: pointer;
+            border-radius: 4px;
+            font-size: 14px;
+            transition: background-color 0.2s;
+            white-space: nowrap;
+            overflow: hidden;
+            text-overflow: ellipsis;
+        }
+        .subnet-button:hover {
+            background-color: rgba(70,70,70,0.9);
+        }
+        .subnet-button.active {
+            background-color: rgba(100,100,100,0.9);
+            border-color: rgba(120,120,120,1);
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <div id="multi-subnet-chart"></div>
+        <div class="subnet-buttons">
+            <button class="subnet-button active" onclick="setAll()">All</button>
+            {% for netuid in sorted_subnet_keys %}
+                <button class="subnet-button" onclick="setSubnet({{ netuid }})">S{{ netuid }}</button>
+            {% endfor %}
+        </div>
+    </div>
+    <script>
+        const figData = {{ fig_json|safe }};
+        const allVisibility = {{ all_visibility|tojson|safe }};
+        const allAnnotations = {{ all_annotations|tojson|safe }};
+
+        const subnetModes = {{ subnet_modes|tojson|safe }};
+
+        Plotly.newPlot('multi-subnet-chart', figData.data, figData.layout);
+
+        function clearActiveButtons() {
+            document.querySelectorAll('.subnet-button').forEach(btn => btn.classList.remove('active'));
+        }
+
+        function setAll() {
+            clearActiveButtons();
+            event.currentTarget.classList.add('active');
+            Plotly.update('multi-subnet-chart',
+                {visible: allVisibility},
+                {annotations: allAnnotations}
+            );
+        }
+
+        function setSubnet(netuid) {
+            clearActiveButtons();
+            event.currentTarget.classList.add('active');
+            const mode = subnetModes[netuid];
+            Plotly.update('multi-subnet-chart',
+                {visible: mode.visible},
+                {annotations: mode.annotations}
+            );
+        }
+    </script>
+</body>
+</html>

meshtensor_cli/src/meshtensor/templates/price-single.j2

@@ -0,0 +1,99 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <title>{{ title }}</title>
+    <script src="https://cdn.plot.ly/plotly-latest.min.js"></script>
+    <style>
+        body {
+            background-color: #000;
+            color: #fff;
+            font-family: Arial, sans-serif;
+            margin: 0;
+            padding: 20px;
+        }
+        .header-container {
+            display: flex;
+            align-items: flex-start;
+            justify-content: space-between;
+            margin-bottom: 20px;
+        }
+        .price-info {
+            max-width: 60%;
+        }
+        .main-price {
+            font-size: 36px;
+            font-weight: 600;
+            margin-bottom: 5px;
+        }
+        .price-change {
+            font-size: 18px;
+            margin-left: 8px;
+            font-weight: 500;
+        }
+        .text-green { color: #00FF00; }
+        .text-red   { color: #FF5555; }
+        .text-blue  { color: #87CEEB; }
+        .text-steel { color: #4682B4; }
+        .text-purple{ color: #DDA0DD; }
+        .text-gold  { color: #FFD700; }
+
+        .sub-stats-row {
+            display: flex;
+            flex-wrap: wrap;
+            margin-top: 10px;
+        }
+        .stat-item {
+            margin-right: 20px;
+            margin-bottom: 6px;
+            font-size: 14px;
+        }
+        .side-stats {
+            min-width: 220px;
+            display: flex;
+            flex-direction: column;
+            align-items: flex-start;
+        }
+        .side-stats div {
+            margin-bottom: 6px;
+            font-size: 14px;
+        }
+        #chart-container {
+            margin-top: 20px;
+            width: 100%;
+            height: 600px;
+        }
+    </style>
+</head>
+<body>
+    <div class="header-container">
+        <div class="price-info">
+            <div class="main-price">
+                {{ "%.6f"|format(stats.current_price) }} {{ stats.symbol }}
+                <span class="price-change {{ "text-green" if stats.change_pct > 0 else "text-red" }}">
+                    {{  "▲" if stats.change_pct > 0 else "▼" }} {{ "%.2f"|format(change_pct) }}%
+                </span>
+            </div>
+            <div class="sub-stats-row">
+                <div class="stat-item">
+                    {{ interval_hours }}h High: <span class="text-green">{{ "%.6f"|format(stats.high) }} {{ stats.symbol }}</span>
+                </div>
+                <div class="stat-item">
+                    {{ interval_hours }}h Low: <span class="text-red">{{ "%.6f"|format(stats.low) }} {{ stats.symbol }}</span>
+                </div>
+            </div>
+        </div>
+        <div class="side-stats">
+            <div>Supply: <span class="text-blue">{{ "%.2f"|format(stats.supply) }} {{ stats.symbol }}</span></div>
+            <div>Market Cap: <span class="text-steel">{{ "%.2f"|format(stats.market_cap) }} τ</span></div>
+            <div>Emission: <span class="text-purple">{{ "%.2f"|format(stats.emission) }} {{ stats.symbol }}</span></div>
+            <div>Stake: <span class="text-gold">{{ "%.2f"|format(stats.stake) }} {{ stats.symbol }}</span></div>
+        </div>
+    </div>
+    <div id="chart-container"></div>
+    <script>
+        var figData = {{ fig_json|safe }};
+        Plotly.newPlot('chart-container', figData.data, figData.layout);
+    </script>
+</body>
+</html>