bittensor-cli 9.22.0__tar.gz → 9.22.2__tar.gz

{bittensor_cli-9.22.0 → bittensor_cli-9.22.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bittensor-cli
-Version: 9.22.0
+Version: 9.22.2
 Summary: Bittensor CLI
 Author: bittensor.com
 Requires-Python: >=3.10
@@ -27,7 +27,7 @@ Requires-Dist: netaddr~=1.3.0
 Requires-Dist: Jinja2
 Requires-Dist: PyYAML~=6.0
 Requires-Dist: rich>=15.0,<16.0
-Requires-Dist: cyscale>=0.3.3,<1.0.0
+Requires-Dist: cyscale==0.4.0
 Requires-Dist: typer~=0.26.0
 Requires-Dist: typing_extensions>4.0.0; python_version<'3.11'
 Requires-Dist: bittensor-wallet==4.1.0

{bittensor_cli-9.22.0 → bittensor_cli-9.22.2}/bittensor_cli/cli.py

@@ -12,7 +12,6 @@ import ssl
 import sys
 import traceback
 import warnings
-from dataclasses import fields
 from pathlib import Path
 from typing import Coroutine, Optional, Union
 
@@ -48,7 +47,6 @@ from bittensor_cli.src import (
 )
 from bittensor_cli.src.bittensor import utils
 from bittensor_cli.src.bittensor.balances import Balance
-from bittensor_cli.src.bittensor.chain_data import SubnetHyperparameters
 from bittensor_cli.src.bittensor.subtensor_interface import (
     SubtensorInterface,
     best_connection,
@@ -4921,7 +4919,7 @@ class CLIManager:
         json_output: bool = Options.json_output,
     ):
         """
-        View one active stake lock and its local projection.
+        View one active stake lock and its lock projection.
 
         If --netuid is omitted, btcli prompts from the coldkey's active lock
         netuids.
@@ -7349,9 +7347,7 @@ class CLIManager:
                     "Param name not supplied with `--no-prompt` flag. Cannot continue"
                 )
                 return False
-            hyperparam_list = sorted(
-                [field.name for field in fields(SubnetHyperparameters)]
-            )
+            hyperparam_list = sorted(HYPERPARAMS.keys())
             console.print("Available hyperparameters:\n")
 
             # Create a table to show hyperparameters with descriptions

{bittensor_cli-9.22.0 → bittensor_cli-9.22.2}/bittensor_cli/src/__init__.py

@@ -581,17 +581,12 @@ class RootSudoOnly(Enum):
 
 HYPERPARAMS = {
     # btcli name: (subtensor method, root-only enum)
-    "rho": ("sudo_set_rho", RootSudoOnly.FALSE),
     "kappa": ("sudo_set_kappa", RootSudoOnly.TRUE),
     "immunity_period": ("sudo_set_immunity_period", RootSudoOnly.FALSE),
     "min_allowed_weights": ("sudo_set_min_allowed_weights", RootSudoOnly.FALSE),
-    "max_weights_limit": ("sudo_set_max_weight_limit", RootSudoOnly.FALSE),
     "tempo": ("sudo_set_tempo", RootSudoOnly.TRUE),
-    "min_difficulty": ("sudo_set_min_difficulty", RootSudoOnly.TRUE),
-    "max_difficulty": ("sudo_set_max_difficulty", RootSudoOnly.FALSE),
     "weights_version": ("sudo_set_weights_version_key", RootSudoOnly.FALSE),
     "weights_rate_limit": ("sudo_set_weights_set_rate_limit", RootSudoOnly.TRUE),
-    "adjustment_interval": ("sudo_set_adjustment_interval", RootSudoOnly.TRUE),
     "activity_cutoff": ("sudo_set_activity_cutoff", RootSudoOnly.FALSE),
     "target_regs_per_interval": (
         "sudo_set_target_registrations_per_interval",
@@ -603,8 +598,6 @@ HYPERPARAMS = {
     "max_regs_per_block": ("sudo_set_max_registrations_per_block", RootSudoOnly.TRUE),
     "serving_rate_limit": ("sudo_set_serving_rate_limit", RootSudoOnly.FALSE),
     "max_validators": ("sudo_set_max_allowed_validators", RootSudoOnly.TRUE),
-    "adjustment_alpha": ("sudo_set_adjustment_alpha", RootSudoOnly.FALSE),
-    "difficulty": ("sudo_set_difficulty", RootSudoOnly.TRUE),
     "commit_reveal_period": (
         "sudo_set_commit_reveal_weights_interval",
         RootSudoOnly.FALSE,
@@ -632,10 +625,16 @@ HYPERPARAMS = {
     "sn_owner_hotkey": ("sudo_set_sn_owner_hotkey", RootSudoOnly.FALSE),
     "subnet_owner_hotkey": ("sudo_set_sn_owner_hotkey", RootSudoOnly.FALSE),
     "recycle_or_burn": ("sudo_set_recycle_or_burn", RootSudoOnly.FALSE),
+    "owner_cut_enabled": ("sudo_set_owner_cut_enabled", RootSudoOnly.FALSE),
+    "owner_cut_auto_lock_enabled": (
+        "sudo_set_owner_cut_auto_lock_enabled",
+        RootSudoOnly.FALSE,
+    ),
     # Note: These are displayed but not directly settable via HYPERPARAMS
     # They are derived or set via other mechanisms
     "alpha_high": ("", RootSudoOnly.FALSE),  # Derived from alpha_values
     "alpha_low": ("", RootSudoOnly.FALSE),  # Derived from alpha_values
+    #
     "subnet_is_active": ("", RootSudoOnly.FALSE),  # Set via btcli subnets start
     "yuma_version": ("", RootSudoOnly.FALSE),  # Related to yuma3_enabled
     "max_allowed_uids": ("sudo_set_max_allowed_uids", RootSudoOnly.FALSE),
@@ -649,12 +648,6 @@ HYPERPARAMS_MODULE = {
 
 # Hyperparameter metadata: descriptions, side-effects, ownership, and documentation links
 HYPERPARAMS_METADATA = {
-    "rho": {
-        "description": "Rho controls the rate at which weights decay over time.",
-        "side_effects": "Changing rho affects how quickly neurons' influence diminishes, impacting consensus dynamics.",
-        "owner_settable": True,
-        "docs_link": "docs.learnbittensor.org/subnets/subnet-hyperparameters#rho",
-    },
     "kappa": {
         "description": "Kappa determines the scaling factor for consensus calculations.",
         "side_effects": "Modifying kappa changes how validator votes are weighted in consensus mechanisms.",
@@ -673,30 +666,12 @@ HYPERPARAMS_METADATA = {
         "owner_settable": True,
         "docs_link": "docs.learnbittensor.org/subnets/subnet-hyperparameters#minallowedweights",
     },
-    "max_weights_limit": {
-        "description": "Maximum number of weight connections a neuron can have with other neurons.",
-        "side_effects": "Limits the maximum out-degree of the network graph, affecting network topology and consensus.",
-        "owner_settable": True,
-        "docs_link": "docs.learnbittensor.org/subnets/subnet-hyperparameters#maxweightslimit",
-    },
     "tempo": {
         "description": "Number of blocks between epoch transitions",
         "side_effects": "Lower tempo means more frequent updates but higher chain load. Higher tempo reduces frequency but may slow responsiveness.",
         "owner_settable": False,
         "docs_link": "docs.learnbittensor.org/subnets/subnet-hyperparameters#tempo",
     },
-    "min_difficulty": {
-        "description": "Minimum proof-of-work difficulty required for registration",
-        "side_effects": "Increasing min_difficulty raises the computational barrier for new neuron registrations.",
-        "owner_settable": False,
-        "docs_link": "docs.learnbittensor.org/subnets/subnet-hyperparameters#mindifficulty",
-    },
-    "max_difficulty": {
-        "description": "Maximum proof-of-work difficulty cap.",
-        "side_effects": "Caps the maximum computational requirement, ensuring registration remains feasible.",
-        "owner_settable": True,
-        "docs_link": "docs.learnbittensor.org/subnets/subnet-hyperparameters#maxdifficulty",
-    },
     "weights_version": {
         "description": "Version key for weight sets.",
         "side_effects": "Changing this invalidates all existing weights, forcing neurons to resubmit weights.",
@@ -709,12 +684,6 @@ HYPERPARAMS_METADATA = {
         "owner_settable": False,
         "docs_link": "docs.learnbittensor.org/subnets/subnet-hyperparameters#weightsratelimit--commitmentratelimit",
     },
-    "adjustment_interval": {
-        "description": "Number of blocks between automatic difficulty adjustments.",
-        "side_effects": "Shorter intervals make difficulty more responsive but may cause volatility. Longer intervals provide stability.",
-        "owner_settable": False,
-        "docs_link": "docs.learnbittensor.org/subnets/subnet-hyperparameters#adjustmentinterval",
-    },
     "activity_cutoff": {
         "description": "Minimum activity level required for neurons to remain active.",
         "side_effects": "Lower values keep more neurons active; higher values prune inactive neurons more aggressively.",
@@ -763,18 +732,6 @@ HYPERPARAMS_METADATA = {
         "owner_settable": False,
         "docs_link": "docs.learnbittensor.org/subnets/subnet-hyperparameters#maxallowedvalidators",
     },
-    "adjustment_alpha": {
-        "description": "Alpha parameter for difficulty adjustment algorithm.",
-        "side_effects": "Higher values make difficulty adjustments more aggressive; lower values provide smoother transitions.",
-        "owner_settable": True,
-        "docs_link": "docs.learnbittensor.org/subnets/subnet-hyperparameters#adjustmentalpha",
-    },
-    "difficulty": {
-        "description": "Current proof-of-work difficulty for registration.",
-        "side_effects": "Directly affects registration cost and time. Higher difficulty makes registration harder and more expensive.",
-        "owner_settable": False,
-        "docs_link": "docs.learnbittensor.org/subnets/subnet-hyperparameters#difficulty",
-    },
     "commit_reveal_period": {
         "description": "Duration (in blocks) for commit-reveal weight submission scheme.",
         "side_effects": "Longer periods provide more time for commits but delay weight revelation. Shorter periods increase frequency.",
@@ -896,6 +853,30 @@ HYPERPARAMS_METADATA = {
         "owner_settable": True,
         "docs_link": "docs.learnbittensor.org/subnets/subnet-hyperparameters#maxalloweduids",
     },
+    "owner_cut_enabled": {
+        "description": "Whether the subnet owner cut is taken from the subnet's emissions.",
+        "side_effects": "When disabled, no owner cut is deducted and the full emission goes to the subnet participants.",
+        "owner_settable": True,
+        "docs_link": "docs.learnbittensor.org/subnets/subnet-hyperparameters#ownercutenabled",
+    },
+    "owner_cut_auto_lock_enabled": {
+        "description": "Whether the subnet owner cut is automatically locked when collected.",
+        "side_effects": "When enabled, the owner cut is auto-locked rather than paid out as liquid stake.",
+        "owner_settable": True,
+        "docs_link": "docs.learnbittensor.org/subnets/subnet-hyperparameters#ownercutautolockenabled",
+    },
+    "burn_half_life": {
+        "description": "Half-life (in blocks) controlling how quickly the registration burn price decays back toward min_burn.",
+        "side_effects": "Larger values make the registration burn price decay more slowly after registrations; smaller values let it fall back to min_burn faster.",
+        "owner_settable": True,
+        "docs_link": "docs.learnbittensor.org/subnets/subnet-hyperparameters#burnhalflife",
+    },
+    "burn_increase_mult": {
+        "description": "Multiplier applied to the registration burn price after each successful registration.",
+        "side_effects": "Higher values make the burn price jump more sharply with each registration, raising the cost of rapid successive registrations.",
+        "owner_settable": True,
+        "docs_link": "docs.learnbittensor.org/subnets/subnet-hyperparameters#burnincreasemult",
+    },
 }
 
 # Help Panels for cli help

{bittensor_cli-9.22.0 → bittensor_cli-9.22.2}/bittensor_cli/src/bittensor/chain_data.py

@@ -1,11 +1,12 @@
+import re
 from abc import abstractmethod
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from decimal import Decimal
 from enum import Enum
-from typing import Optional, Any, Union
+from typing import Optional, Any
 
 import netaddr
-from scalecodec.utils.math import FixedPoint, fixed_to_decimal
+from scalecodec.utils.math import fixed_to_decimal
 from scalecodec.utils.ss58 import ss58_encode
 
 from bittensor_cli.src.bittensor.balances import Balance, fixed_to_float
@@ -69,7 +70,7 @@ class AxonInfo:
         return self.ip != "0.0.0.0"
 
     @classmethod
-    def from_neuron_info(cls, neuron_info: dict) -> "AxonInfo":
+    def from_neuron_info(cls, neuron_info: dict) -> Self:
         """
         Converts a dictionary to an AxonInfo object.
 
@@ -121,11 +122,11 @@ class LockState:
     last_update: int
 
     @classmethod
-    def zero(cls, now: int) -> "LockState":
+    def zero(cls, now: int) -> Self:
         return cls(locked_mass=0, conviction=Decimal(0), last_update=now)
 
     @classmethod
-    def from_any(cls, decoded: Any) -> "LockState":
+    def from_any(cls, decoded: Any) -> Self:
         return cls(
             locked_mass=int(decoded["locked_mass"]),
             conviction=fixed_to_decimal(decoded["conviction"]),
@@ -156,129 +157,103 @@ class SubnetLockAggregates:
     owner_decay_lock: Optional[LockState]
 
 
+# Fixed-point type tags (e.g. `U64F64`, `I32F32`) encode their integer and
+# fractional bit-widths in the name; the second group gives the fractional bits.
+_FIXED_POINT_TAG = re.compile(r"^[UI]\d+F(\d+)$")
+
+
 @dataclass
 class SubnetHyperparameters(InfoBase):
     """
-    This class represents the hyperparameters for a subnet.
-    Attributes:
-        rho (int): The rate of decay of some value.
-        kappa (int): A constant multiplier used in calculations.
-        immunity_period (int): The period during which immunity is active.
-        min_allowed_weights (int): Minimum allowed weights.
-        max_weight_limit (float): Maximum weight limit.
-        tempo (int): The tempo or rate of operation.
-        min_difficulty (int): Minimum difficulty for some operations.
-        max_difficulty (int): Maximum difficulty for some operations.
-        weights_version (int): The version number of the weights used.
-        weights_rate_limit (int): Rate limit for processing weights.
-        adjustment_interval (int): Interval at which adjustments are made.
-        activity_cutoff (int): Activity cutoff threshold.
-        registration_allowed (bool): Indicates if registration is allowed.
-        target_regs_per_interval (int): Target number of registrations per interval.
-        min_burn (int): Minimum burn value.
-        max_burn (int): Maximum burn value.
-        bonds_moving_avg (int): Moving average of bonds.
-        max_regs_per_block (int): Maximum number of registrations per block.
-        serving_rate_limit (int): Limit on the rate of service.
-        max_validators (int): Maximum number of validators.
-        adjustment_alpha (int): Alpha value for adjustments.
-        difficulty (int): Difficulty level.
-        commit_reveal_period (int): Interval for commit-reveal weights.
-        commit_reveal_weights_enabled (bool): Flag indicating if commit-reveal weights are enabled.
-        alpha_high (int): High value of alpha.
-        alpha_low (int): Low value of alpha.
-        liquid_alpha_enabled (bool): Flag indicating if liquid alpha is enabled.
-        alpha_sigmoid_steepness (float):
-        yuma_version (int): Version of yuma.
-        subnet_is_active (bool): Indicates if subnet is active after START CALL.
-        transfers_enabled (bool): Flag indicating if transfers are enabled.
-        bonds_reset_enabled (bool): Flag indicating if bonds are reset enabled.
-        user_liquidity_enabled (bool): Flag indicating if user liquidity is enabled.
+    Dynamic container for a subnet's hyperparameters.
+
+    The chain returns hyperparameters from the `get_subnet_hyperparams_v3`
+    runtime API as a list of `{"name": str, "value": {<type_tag>: <payload>}}`
+    records. Rather than a fixed struct, this class decodes whatever records the
+    runtime returns into a plain ``name -> value`` mapping, so hyperparameters can
+    be added to or removed from the chain without requiring code changes here.
+
+    Values are decoded to native Python types (`int` for integers and balances in
+    rao, `bool` for booleans, `float` for fixed-point numbers). Human-readable
+    normalization for display happens separately in
+    :func:`bittensor_cli.src.bittensor.utils.normalize_hyperparameters`.
+
+    Decoded values are exposed via attribute access (``params.tempo``), item access
+    (`params["tempo"]`), membership tests (`"tempo" in params`), and iteration
+    (`params.items()`, `params.keys()`, `params.values()`).
     """
 
-    rho: int
-    kappa: int
-    immunity_period: int
-    min_allowed_weights: int
-    max_weight_limit: float
-    tempo: int
-    min_difficulty: int
-    max_difficulty: int
-    weights_version: int
-    weights_rate_limit: int
-    adjustment_interval: int
-    activity_cutoff: int
-    registration_allowed: bool
-    target_regs_per_interval: int
-    min_burn: int
-    max_burn: int
-    bonds_moving_avg: int
-    max_regs_per_block: int
-    serving_rate_limit: int
-    max_validators: int
-    adjustment_alpha: int
-    difficulty: int
-    commit_reveal_period: int
-    commit_reveal_weights_enabled: bool
-    alpha_high: int
-    alpha_low: int
-    liquid_alpha_enabled: bool
-    alpha_sigmoid_steepness: float
-    yuma_version: int
-    subnet_is_active: bool
-    transfers_enabled: bool
-    bonds_reset_enabled: bool
-    user_liquidity_enabled: bool
-    burn_increase_mult: FixedPoint
-    burn_half_life: int
+    hyperparameters: dict[str, Any] = field(default_factory=dict)
+
+    @staticmethod
+    def _decode_value(value: Any) -> Any:
+        """Decode a single ``{<type_tag>: <payload>}`` hyperparameter value.
+
+        Unrecognized or already-flat values are returned unchanged so callers can
+        pass in pre-decoded data (e.g. in tests).
+        """
+        if not isinstance(value, dict) or len(value) != 1:
+            return value
+        ((type_tag, payload),) = value.items()
+        if type_tag == "Bool":
+            return bool(payload)
+        if match := _FIXED_POINT_TAG.match(type_tag):
+            return fixed_to_float(payload, frac_bits=int(match.group(1)))
+        # Everything else (U8/U16/U32/U64/U128, signed ints, TaoBalance, ...) is an
+        # integer; balances are left as raw rao for downstream normalization.
+        try:
+            return int(payload)
+        except (TypeError, ValueError):
+            return payload
 
     @classmethod
     def _fix_decoded(
         cls,
-        decoded: Union[dict, "SubnetHyperparameters"],
-    ) -> "SubnetHyperparameters":
-        burn_increase_mult: FixedPoint = decoded["burn_increase_mult"]
-        burn_half_life: int = decoded["burn_half_life"]
+        decoded: list | dict | Self,
+    ) -> Self:
+        if isinstance(decoded, SubnetHyperparameters):
+            return decoded
+        if isinstance(decoded, dict):
+            # Already keyed by name (either {name: {tag: payload}} or flat).
+            entries = decoded.items()
+        else:
+            # V3 format: list of {"name": ..., "value": ...} records.
+            entries = ((record["name"], record["value"]) for record in decoded)
         return cls(
-            activity_cutoff=decoded["activity_cutoff"],
-            adjustment_alpha=decoded["adjustment_alpha"],
-            adjustment_interval=decoded["adjustment_interval"],
-            alpha_high=decoded["alpha_high"],
-            alpha_low=decoded["alpha_low"],
-            alpha_sigmoid_steepness=fixed_to_float(
-                decoded["alpha_sigmoid_steepness"], frac_bits=32
-            ),
-            bonds_moving_avg=decoded["bonds_moving_avg"],
-            bonds_reset_enabled=decoded["bonds_reset_enabled"],
-            commit_reveal_weights_enabled=decoded["commit_reveal_weights_enabled"],
-            commit_reveal_period=decoded["commit_reveal_period"],
-            difficulty=decoded["difficulty"],
-            immunity_period=decoded["immunity_period"],
-            kappa=decoded["kappa"],
-            liquid_alpha_enabled=decoded["liquid_alpha_enabled"],
-            max_burn=decoded["max_burn"],
-            max_difficulty=decoded["max_difficulty"],
-            max_regs_per_block=decoded["max_regs_per_block"],
-            max_validators=decoded["max_validators"],
-            max_weight_limit=decoded["max_weights_limit"],
-            min_allowed_weights=decoded["min_allowed_weights"],
-            min_burn=decoded["min_burn"],
-            min_difficulty=decoded["min_difficulty"],
-            registration_allowed=decoded["registration_allowed"],
-            rho=decoded["rho"],
-            serving_rate_limit=decoded["serving_rate_limit"],
-            subnet_is_active=decoded["subnet_is_active"],
-            target_regs_per_interval=decoded["target_regs_per_interval"],
-            tempo=decoded["tempo"],
-            transfers_enabled=decoded["transfers_enabled"],
-            user_liquidity_enabled=decoded["user_liquidity_enabled"],
-            weights_rate_limit=decoded["weights_rate_limit"],
-            weights_version=decoded["weights_version"],
-            yuma_version=decoded["yuma_version"],
-            burn_increase_mult=burn_increase_mult,
-            burn_half_life=burn_half_life,
+            hyperparameters={name: cls._decode_value(value) for name, value in entries}
         )
 
+    def __getattr__(self, item: str) -> Any:
+        # Only invoked when normal attribute lookup fails, so ``hyperparameters``
+        # itself is always resolved normally and this cannot recurse.
+        try:
+            return self.__dict__["hyperparameters"][item]
+        except KeyError:
+            raise AttributeError(
+                f"{type(self).__name__!r} object has no hyperparameter {item!r}"
+            )
+
+    def __getitem__(self, item: str) -> Any:
+        return self.hyperparameters[item]
+
+    def __contains__(self, item: str) -> bool:
+        return item in self.hyperparameters
+
+    def __iter__(self):
+        return iter(self.hyperparameters)
+
+    def get(self, item: str, default: Any = None) -> Any:
+        return self.hyperparameters.get(item, default)
+
+    def items(self):
+        return self.hyperparameters.items()
+
+    def keys(self):
+        return self.hyperparameters.keys()
+
+    def values(self):
+        return self.hyperparameters.values()
+
 
 @dataclass
 class StakeInfo(InfoBase):
@@ -295,7 +270,7 @@ class StakeInfo(InfoBase):
     is_registered: bool
 
     @classmethod
-    def _fix_decoded(cls, decoded: Any) -> "StakeInfo":
+    def _fix_decoded(cls, decoded: Any) -> Self:
         hotkey = decoded.get("hotkey")
         coldkey = decoded.get("coldkey")
         netuid = int(decoded.get("netuid"))
@@ -353,7 +328,7 @@ class NeuronInfo(InfoBase):
         neuron_lite: "NeuronInfoLite",
         weights_as_dict: dict[int, list[tuple[int, int]]],
         bonds_as_dict: dict[int, list[tuple[int, int]]],
-    ) -> "NeuronInfo":
+    ) -> Self:
         n_dict = neuron_lite.__dict__
         n_dict["weights"] = weights_as_dict.get(neuron_lite.uid, [])
         n_dict["bonds"] = bonds_as_dict.get(neuron_lite.uid, [])
@@ -389,7 +364,7 @@ class NeuronInfo(InfoBase):
         return neuron
 
     @classmethod
-    def _fix_decoded(cls, decoded: Any) -> "NeuronInfo":
+    def _fix_decoded(cls, decoded: Any) -> Self:
         netuid = decoded.get("netuid")
         stake_dict = process_stake_data(decoded.get("stake"), netuid=netuid)
         total_stake = sum(stake_dict.values()) if stake_dict else Balance(0)
@@ -454,7 +429,7 @@ class NeuronInfoLite(InfoBase):
     dividends: float
     last_update: int
     validator_permit: bool
-    axon_info: AxonInfo
+    axon_info: Optional[AxonInfo]
     pruning_score: int
     is_null: bool = False
 
@@ -485,7 +460,7 @@ class NeuronInfoLite(InfoBase):
         return neuron
 
     @classmethod
-    def _fix_decoded(cls, decoded: Union[dict, "NeuronInfoLite"]) -> "NeuronInfoLite":
+    def _fix_decoded(cls, decoded: dict | Self) -> Self:
         active = decoded.get("active")
         axon_info = decoded.get("axon_info", {})
         coldkey = decoded.get("coldkey")
@@ -572,7 +547,7 @@ class DelegateInfo(InfoBase):
     total_daily_return: Balance  # Total daily return of the delegate
 
     @classmethod
-    def _fix_decoded(cls, decoded: "DelegateInfo") -> "DelegateInfo":
+    def _fix_decoded(cls, decoded: Self) -> Self:
         hotkey = decoded.get("hotkey_ss58")
         owner = decoded.get("owner_ss58")
         nominators = [(x, Balance.from_rao(y)) for x, y in decoded.get("nominators")]
@@ -611,7 +586,7 @@ class DelegateInfoLite(InfoBase):
     owner_stake: Balance  # Own stake of the delegate
 
     @classmethod
-    def _fix_decoded(cls, decoded: Any) -> "DelegateInfoLite":
+    def _fix_decoded(cls, decoded: Any) -> Self:
         """Fixes the decoded values."""
         decoded_take = decoded.get("take")
 
@@ -654,7 +629,7 @@ class SubnetInfo(InfoBase):
     owner_ss58: str
 
     @classmethod
-    def _fix_decoded(cls, decoded: "SubnetInfo") -> "SubnetInfo":
+    def _fix_decoded(cls, decoded: Self) -> Self:
         return cls(
             netuid=decoded.get("netuid"),
             rho=decoded.get("rho"),
@@ -694,7 +669,7 @@ class SubnetIdentity(InfoBase):
     additional: str
 
     @classmethod
-    def _fix_decoded(cls, decoded: dict) -> "SubnetIdentity":
+    def _fix_decoded(cls, decoded: dict) -> Self:
         if isinstance(subnet_name := decoded["subnet_name"], list):
             subnet_name = bytes(subnet_name).decode("utf-8")
         return cls(
@@ -737,7 +712,7 @@ class DynamicInfo(InfoBase):
     moving_price: float
 
     @classmethod
-    def _fix_decoded(cls, decoded: Any) -> "DynamicInfo":
+    def _fix_decoded(cls, decoded: Any) -> Self:
         """Returns a DynamicInfo object from a decoded DynamicInfo dictionary."""
 
         netuid = int(decoded.get("netuid"))
@@ -924,9 +899,7 @@ class ColdkeySwapAnnouncementInfo(InfoBase):
     new_coldkey_hash: str
 
     @classmethod
-    def _fix_decoded(
-        cls, coldkey: str, decoded: tuple
-    ) -> "ColdkeySwapAnnouncementInfo":
+    def _fix_decoded(cls, coldkey: str, decoded: tuple) -> Self:
         execution_block, new_coldkey_hash = decoded
         return cls(
             coldkey=coldkey,
@@ -957,7 +930,7 @@ class SubnetState(InfoBase):
     emission_history: list[list[int]]
 
     @classmethod
-    def _fix_decoded(cls, decoded: Any) -> "SubnetState":
+    def _fix_decoded(cls, decoded: Any) -> Self:
         netuid = decoded.get("netuid")
         return cls(
             netuid=netuid,
@@ -1005,7 +978,7 @@ class ChainIdentity(InfoBase):
     additional: str
 
     @classmethod
-    def _from_dict(cls, decoded: dict) -> "ChainIdentity":
+    def _from_dict(cls, decoded: dict) -> Self:
         """Returns a ChainIdentity object from decoded chain data."""
         return cls(
             name=decoded["name"],
@@ -1122,7 +1095,7 @@ class MetagraphInfo(InfoBase):
     subuid: int = 0
 
     @classmethod
-    def _fix_decoded(cls, decoded: dict) -> "MetagraphInfo":
+    def _fix_decoded(cls, decoded: dict) -> Self:
         """Returns a MetagraphInfo object from decoded chain data."""
         # Subnet index
         _netuid, _subuid = get_netuid_and_subuid_by_storage_index(decoded["netuid"])
@@ -1236,7 +1209,7 @@ class SimSwapResult:
     alpha_fee: Balance
 
     @classmethod
-    def from_dict(cls, d: dict, netuid: int) -> "SimSwapResult":
+    def from_dict(cls, d: dict, netuid: int) -> Self:
         return cls(
             tao_amount=Balance.from_rao(d["tao_amount"]).set_unit(0),
             alpha_amount=Balance.from_rao(d["alpha_amount"]).set_unit(netuid),
@@ -1261,7 +1234,7 @@ class CrowdloanData(InfoBase):
     call_details: Optional[dict] = None
 
     @classmethod
-    def _fix_decoded(cls, decoded: dict[str, Any]) -> "CrowdloanData":
+    def _fix_decoded(cls, decoded: dict[str, Any]) -> Self:
         creator = decoded.get("creator")
         funds_account = decoded.get("funds_account")
         target_address = decoded.get("target_address")

{bittensor_cli-9.22.0 → bittensor_cli-9.22.2}/bittensor_cli/src/bittensor/subtensor_interface.py

@@ -83,7 +83,7 @@ class SubtensorInterface:
             self.chain_endpoint = Constants.network_map[network]
             self.network = network
             if network == "local":
-                console.log(
+                console.print(
                     "[yellow]Warning[/yellow]: Verify your local subtensor is running on port 9944."
                 )
         else:
@@ -1631,7 +1631,7 @@ class SubtensorInterface:
 
     async def get_subnet_hyperparameters(
         self, netuid: int, block_hash: Optional[str] = None
-    ) -> Optional[Union[list, SubnetHyperparameters]]:
+    ) -> SubnetHyperparameters:
         """
         Retrieves the hyperparameters for a specific subnet within the Bittensor network. These hyperparameters
         define the operational settings and rules governing the subnet's behavior.
@@ -1644,31 +1644,14 @@ class SubtensorInterface:
         Understanding the hyperparameters is crucial for comprehending how subnets are configured and
         managed, and how they interact with the network's consensus and incentive mechanisms.
         """
-        if block_hash is None:
-            block_hash = await self.substrate.get_chain_head()
-        result, burn_increase_mult, burn_half_life = await asyncio.gather(
-            self.query_runtime_api(
-                runtime_api="SubnetInfoRuntimeApi",
-                method="get_subnet_hyperparams_v2",
-                params=[netuid],
-                block_hash=block_hash,
-            ),
-            self.substrate.query(
-                "SubtensorModule", "BurnIncreaseMult", [netuid], block_hash=block_hash
-            ),
-            self.substrate.query(
-                "SubtensorModule", "BurnHalfLife", [netuid], block_hash=block_hash
-            ),
+        result = await self.query_runtime_api(
+            runtime_api="SubnetInfoRuntimeApi",
+            method="get_subnet_hyperparams_v3",
+            params=[netuid],
+            block_hash=block_hash,
         )
-        if not result:
-            return []
-
-        additional = {
-            "burn_increase_mult": burn_increase_mult.value,
-            "burn_half_life": burn_half_life.value,
-        }
 
-        return SubnetHyperparameters.from_any(result | additional)
+        return SubnetHyperparameters.from_any(result)
 
     async def get_subnet_mechanisms(
         self, netuid: int, block_hash: Optional[str] = None

{bittensor_cli-9.22.0 → bittensor_cli-9.22.2}/bittensor_cli/src/bittensor/utils.py

@@ -31,7 +31,6 @@ import typer
 
 from bittensor_cli.src.bittensor.balances import Balance
 from bittensor_cli.src import defaults, Constants
-from scalecodec.utils.math import fixed_to_float
 
 if TYPE_CHECKING:
     from bittensor_cli.src.bittensor.chain_data import SubnetHyperparameters
@@ -848,21 +847,18 @@ def normalize_hyperparameters(
         "max_difficulty": u64_normalized_float,
         "difficulty": u64_normalized_float,
         "bonds_moving_avg": u64_normalized_float,
-        "max_weight_limit": u16_normalized_float,
+        "max_weights_limit": u16_normalized_float,
         "kappa": u16_normalized_float,
         "alpha_high": u16_normalized_float,
         "alpha_low": u16_normalized_float,
         "alpha_sigmoid_steepness": u16_normalized_float,
         "min_burn": Balance.from_rao,
         "max_burn": Balance.from_rao,
-        "burn_increase_mult": fixed_to_float,
-        "burn_half_life": u16_normalized_float,
     }
 
     normalized_values: list[tuple[str, str, str]] = []
-    subnet_dict = subnet.__dict__
 
-    for param, value in subnet_dict.items():
+    for param, value in subnet.items():
         try:
             if param in param_mappings:
                 norm_value = param_mappings[param](value)

{bittensor_cli-9.22.0 → bittensor_cli-9.22.2}/bittensor_cli/src/commands/lock/list.py

@@ -96,7 +96,7 @@ async def stake_lock_show(
     verbose: bool = False,
     show_graph: bool = True,
 ) -> None:
-    """Display one active stake lock and its local projection."""
+    """Display one active stake lock and its lock projection."""
     if coldkey_ss58 is None:
         raise ValueError("coldkey_ss58 is required")
 

{bittensor_cli-9.22.0 → bittensor_cli-9.22.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "flit_core.buildapi"
 
 [project]
 name = "bittensor-cli"
-version = "9.22.0"
+version = "9.22.2"
 description = "Bittensor CLI"
 readme = "README.md"
 authors = [
@@ -37,7 +37,7 @@ dependencies = [
     "Jinja2",
     "PyYAML~=6.0",
     "rich>=15.0,<16.0",
-    "cyscale>=0.3.3,<1.0.0",
+    "cyscale==0.4.0",
     "typer~=0.26.0",
     "typing_extensions>4.0.0; python_version<'3.11'",
     "bittensor-wallet==4.1.0",